| blob | b039227c3c257bc5279a694a66bd4f3f7e74ec09 |
1 /*-------------------------------------------------------------------------
2 *
3 * tablecmds.c
4 * Commands for creating and altering table structures and settings
5 *
6 * Portions Copyright (c) 1996-2008, 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: */
141 /* Objects to rebuild after completing ALTER TYPE operations */
148 /* Struct describing one new constraint to check in Phase 3 scan */
149 /* Note: new NOT NULL constraints are handled elsewhere */
151 {
160 /*
161 * Struct describing one new column value that needs to be computed during
162 * Phase 3 copy (this could be either a new column with a non-null default, or
163 * a column that we're changing the type of). Columns without such an entry
164 * are just copied from the old table during ATRewriteTable. Note that the
165 * expr is an expression over *old* table values.
166 */
168 {
174 /*
175 * Error-reporting support for RemoveRelations
176 */
177 struct dropmsgstrings
178 {
185 };
189 ERRCODE_UNDEFINED_TABLE,
195 ERRCODE_UNDEFINED_TABLE,
201 ERRCODE_UNDEFINED_TABLE,
207 ERRCODE_UNDEFINED_OBJECT,
213 ERRCODE_UNDEFINED_OBJECT,
219 };
251 Oid constraintOid);
284 DropBehavior behavior,
298 DropBehavior behavior,
309 Oid newOwnerId);
326 /* ----------------------------------------------------------------
327 * DefineRelation
328 * Creates a new relation.
329 *
330 * If successful, returns the OID of the new relation.
331 * ----------------------------------------------------------------
332 */
333 Oid
335 {
337 Oid namespaceId;
339 Oid relationId;
340 Oid tablespaceId;
341 Relation rel;
342 TupleDesc descriptor;
349 Datum reloptions;
351 AttrNumber attnum;
353 /*
354 * Truncate relname to appropriate length (probably a waste of time, as
355 * parser should have done this already).
356 */
359 /*
360 * Check consistency of arguments
361 */
367 /*
368 * Look up the namespace in which we are supposed to create the relation.
369 * Check we have permission to create there. Skip check if bootstrapping,
370 * since permissions machinery may not be working yet.
371 */
375 {
376 AclResult aclresult;
379 ACL_CREATE);
383 }
385 /*
386 * Select tablespace to use. If not specified, use default tablespace
387 * (which may in turn default to database's default).
388 */
390 {
397 }
398 else
399 {
401 /* note InvalidOid is OK in this case */
402 }
404 /* Check permissions except when using database's default */
406 {
407 AclResult aclresult;
410 ACL_CREATE);
414 }
416 /*
417 * Parse and validate reloptions, if any.
418 */
423 /*
424 * Look up inheritance ancestors and generate relation schema, including
425 * inherited attributes.
426 */
431 /*
432 * Create a tuple descriptor from the relation schema. Note that this
433 * deals with column names, types, and NOT NULL constraints, but not
434 * default values or CHECK constraints; we handle those below.
435 */
441 /*
442 * Find columns with default values and prepare for insertion of the
443 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
444 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
445 * while raw defaults go into a list of RawColumnDefault structs that
446 * will be processed by AddRelationNewConstraints. (We can't deal with
447 * raw expressions until we can do transformExpr.)
448 *
449 * We can set the atthasdef flags now in the tuple descriptor; this just
450 * saves StoreAttrDefault from having to do an immediate update of the
451 * pg_attribute rows.
452 */
458 {
461 attnum++;
464 {
474 }
476 {
488 }
489 }
491 /*
492 * Create the relation. Inherited defaults and constraints are passed
493 * in for immediate handling --- since they don't need parsing, they
494 * can be stored immediately.
495 */
497 namespaceId,
498 tablespaceId,
499 InvalidOid,
501 descriptor,
503 old_constraints),
504 relkind,
506 localHasOids,
507 parentOidCount,
509 reloptions,
510 allowSystemTableMods);
514 /*
515 * We must bump the command counter to make the newly-created relation
516 * tuple visible for opening.
517 */
520 /*
521 * Open the new relation and acquire exclusive lock on it. This isn't
522 * really necessary for locking out other backends (since they can't see
523 * the new rel anyway until we commit), but it keeps the lock manager from
524 * complaining about deadlock risks.
525 */
528 /*
529 * Now add any newly specified column default values and CHECK constraints
530 * to the new relation. These are passed to us in the form of raw
531 * parsetrees; we need to transform them to executable expression trees
532 * before they can be added. The most convenient way to do that is to
533 * apply the parser's transformExpr routine, but transformExpr doesn't
534 * work unless we have a pre-existing relation. So, the transformation has
535 * to be postponed to this final step of CREATE TABLE.
536 */
541 /*
542 * Clean up. We keep lock on new relation (although it shouldn't be
543 * visible to anyone else anyway, until commit).
544 */
548 }
550 /*
551 * Emit the right error or warning message for a "DROP" command issued on a
552 * non-existent relation
553 */
554 static void
556 {
560 {
562 {
564 {
568 }
569 else
570 {
573 }
574 }
575 }
578 }
580 /*
581 * Emit the right error message for a "DROP" command issued on a
582 * relation of the wrong type
583 */
584 static void
586 {
598 /* wrongkind could be something we don't have in our table... */
604 }
606 /*
607 * RemoveRelations
608 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW
609 */
610 void
612 {
617 /*
618 * First we identify all the relations, then we delete them in a single
619 * performMultipleDeletions() call. This is to avoid unwanted
620 * DROP RESTRICT errors if one of the relations depends on another.
621 */
623 /* Determine required relkind */
625 {
647 }
649 /* Lock and validate each relation; build a list of object addresses */
653 {
655 Oid relOid;
656 HeapTuple tuple;
657 Form_pg_class classform;
658 ObjectAddress obj;
660 /*
661 * These next few steps are a great deal like relation_openrv, but we
662 * don't bother building a relcache entry since we don't need it.
663 *
664 * Check for shared-cache-inval messages before trying to access the
665 * relation. This is needed to cover the case where the name
666 * identifies a rel that has been dropped and recreated since the
667 * start of our transaction: if we don't flush the old syscache entry,
668 * then we'll latch onto that entry and suffer an error later.
669 */
672 /* Look up the appropriate relation using namespace search */
675 /* Not there? */
677 {
680 }
682 /*
683 * In DROP INDEX, attempt to acquire lock on the parent table before
684 * locking the index. index_drop() will need this anyway, and since
685 * regular queries lock tables before their indexes, we risk deadlock
686 * if we do it the other way around. No error if we don't find a
687 * pg_index entry, though --- that most likely means it isn't an
688 * index, and we'll fail below.
689 */
691 {
696 {
701 }
702 }
704 /* Get the lock before trying to fetch the syscache entry */
717 /* Allow DROP to either table owner or schema owner */
729 /* OK, we're ready to delete this one */
737 }
742 }
744 /*
745 * ExecuteTruncate
746 * Executes a TRUNCATE command.
747 *
748 * This is a multi-relation truncate. We first open and grab exclusive
749 * lock on all relations involved, checking permissions and otherwise
750 * verifying that the relation is OK for truncation. In CASCADE mode,
751 * relations having FK references to the targeted relations are automatically
752 * added to the group; in RESTRICT mode, we check that all FK references are
753 * internal to the group that's being truncated. Finally all the relations
754 * are truncated and reindexed.
755 */
756 void
758 {
767 /*
768 * Open, exclusive-lock, and check all the explicitly-specified relations
769 */
771 {
773 Relation rel;
776 /* don't throw error for "TRUNCATE foo, foo" */
778 {
781 }
785 }
787 /*
788 * In CASCADE mode, suck in all referencing relations as well. This
789 * requires multiple iterations to find indirectly-dependent relations. At
790 * each phase, we need to exclusive-lock new rels before looking for their
791 * dependencies, else we might miss something. Also, we check each rel as
792 * soon as we open it, to avoid a faux pas such as holding lock for a long
793 * time on a rel we have no permissions for.
794 */
796 {
798 {
806 {
808 Relation rel;
817 }
818 }
819 }
821 /*
822 * Check foreign key references. In CASCADE mode, this should be
823 * unnecessary since we just pulled in all the references; but as a
824 * cross-check, do it anyway if in an Assert-enabled build.
825 */
826 #ifdef USE_ASSERT_CHECKING
828 #else
831 #endif
833 /*
834 * If we are asked to restart sequences, find all the sequences,
835 * lock them (we only need AccessShareLock because that's all that
836 * ALTER SEQUENCE takes), and check permissions. We want to do this
837 * early since it's pointless to do all the truncation work only to fail
838 * on sequence permissions.
839 */
841 {
843 {
849 {
851 Relation seq_rel;
855 /* This check must match AlterSequence! */
863 }
864 }
865 }
867 /* Prepare to catch AFTER triggers. */
870 /*
871 * To fire triggers, we'll need an EState as well as a ResultRelInfo
872 * for each relation.
873 */
879 {
883 rel,
887 resultRelInfo++;
888 }
892 /*
893 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
894 * truncating (this is because one of them might throw an error).
895 * Also, if we were to allow them to prevent statement execution,
896 * that would need to be handled here.
897 */
900 {
903 resultRelInfo++;
904 }
906 /*
907 * OK, truncate each table.
908 */
910 {
912 Oid heap_relid;
913 Oid toast_relid;
915 /*
916 * Create a new empty storage file for the relation, and assign it as
917 * the relfilenode value. The old storage file is scheduled for
918 * deletion at commit.
919 */
925 /*
926 * The same for the toast table, if any.
927 */
929 {
933 }
935 /*
936 * Reconstruct the indexes to match, and we're done.
937 */
939 }
941 /*
942 * Process all AFTER STATEMENT TRUNCATE triggers.
943 */
946 {
949 resultRelInfo++;
950 }
952 /* Handle queued AFTER triggers */
955 /* We can clean up the EState now */
958 /* And close the rels (can't do this while EState still holds refs) */
960 {
964 }
966 /*
967 * Lastly, restart any owned sequences if we were asked to. This is done
968 * last because it's nontransactional: restarts will not roll back if
969 * we abort later. Hence it's important to postpone them as long as
970 * possible. (This is also a big reason why we locked and
971 * permission-checked the sequences beforehand.)
972 */
974 {
978 {
982 }
983 }
984 }
986 /*
987 * Check that a given rel is safe to truncate. Subroutine for ExecuteTruncate
988 */
989 static void
991 {
992 AclResult aclresult;
994 /* Only allow truncate on regular tables */
1001 /* Permissions checks */
1003 ACL_TRUNCATE);
1014 /*
1015 * We can never allow truncation of shared or nailed-in-cache relations,
1016 * because we can't support changing their relfilenode values.
1017 */
1024 /*
1025 * Don't allow truncate on temp tables of other backends ... their local
1026 * buffer manager is not going to cope.
1027 */
1033 /*
1034 * Also check for active uses of the relation in the current transaction,
1035 * including open scans and pending AFTER trigger events.
1036 */
1038 }
1040 /*----------
1041 * MergeAttributes
1042 * Returns new schema given initial schema and superclasses.
1043 *
1044 * Input arguments:
1045 * 'schema' is the column/attribute definition for the table. (It's a list
1046 * of ColumnDef's.) It is destructively changed.
1047 * 'supers' is a list of names (as RangeVar nodes) of parent relations.
1048 * 'istemp' is TRUE if we are creating a temp relation.
1049 *
1050 * Output arguments:
1051 * 'supOids' receives a list of the OIDs of the parent relations.
1052 * 'supconstr' receives a list of constraints belonging to the parents,
1053 * updated as necessary to be valid for the child.
1054 * 'supOidCount' is set to the number of parents that have OID columns.
1055 *
1056 * Return value:
1057 * Completed schema list.
1058 *
1059 * Notes:
1060 * The order in which the attributes are inherited is very important.
1061 * Intuitively, the inherited attributes should come first. If a table
1062 * inherits from multiple parents, the order of those attributes are
1063 * according to the order of the parents specified in CREATE TABLE.
1064 *
1065 * Here's an example:
1066 *
1067 * create table person (name text, age int4, location point);
1068 * create table emp (salary int4, manager text) inherits(person);
1069 * create table student (gpa float8) inherits (person);
1070 * create table stud_emp (percent int4) inherits (emp, student);
1071 *
1072 * The order of the attributes of stud_emp is:
1073 *
1074 * person {1:name, 2:age, 3:location}
1075 * / \
1076 * {6:gpa} student emp {4:salary, 5:manager}
1077 * \ /
1078 * stud_emp {7:percent}
1079 *
1080 * If the same attribute name appears multiple times, then it appears
1081 * in the result table in the proper location for its first appearance.
1082 *
1083 * Constraints (including NOT NULL constraints) for the child table
1084 * are the union of all relevant constraints, from both the child schema
1085 * and parent tables.
1086 *
1087 * The default value for a child column is defined as:
1088 * (1) If the child schema specifies a default, that value is used.
1089 * (2) If neither the child nor any parent specifies a default, then
1090 * the column will not have a default.
1091 * (3) If conflicting defaults are inherited from different parents
1092 * (and not overridden by the child), an error is raised.
1093 * (4) Otherwise the inherited default is used.
1094 * Rule (3) is new in Postgres 7.1; in earlier releases you got a
1095 * rather arbitrary choice of which parent default to use.
1096 *----------
1097 */
1101 {
1111 /*
1112 * Check for and reject tables with too many columns. We perform this
1113 * check relatively early for two reasons: (a) we don't run the risk of
1114 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
1115 * okay if we're processing <= 1600 columns, but could take minutes to
1116 * execute if the user attempts to create a table with hundreds of
1117 * thousands of columns.
1118 *
1119 * Note that we also need to check that any we do not exceed this figure
1120 * after including columns from inherited relations.
1121 */
1126 MaxHeapAttributeNumber)));
1128 /*
1129 * Check for duplicate names in the explicit list of attributes.
1130 *
1131 * Although we might consider merging such entries in the same way that we
1132 * handle name conflicts for inherited attributes, it seems to make more
1133 * sense to assume such conflicts are errors.
1134 */
1136 {
1141 {
1149 }
1150 }
1152 /*
1153 * Scan the parents left-to-right, and merge their attributes to form a
1154 * list of inherited attributes (inhSchema). Also check to see if we need
1155 * to inherit an OID column.
1156 */
1159 {
1161 Relation relation;
1162 TupleDesc tupleDesc;
1165 AttrNumber parent_attno;
1174 /* Permanent rels cannot inherit from temporary ones */
1181 /*
1182 * We should have an UNDER permission flag for this, but for now,
1183 * demand that creator of a child table own the parent.
1184 */
1189 /*
1190 * Reject duplications in the list of parents.
1191 */
1201 parentsWithOids++;
1206 /*
1207 * newattno[] will contain the child-table attribute numbers for the
1208 * attributes of this parent table. (They are not the same for
1209 * parents after the first one, nor if we have dropped columns.)
1210 */
1215 parent_attno++)
1216 {
1222 /*
1223 * Ignore dropped columns in the parent.
1224 */
1226 {
1227 /*
1228 * change_varattnos_of_a_node asserts that this is greater
1229 * than zero, so if anything tries to use it, we should find
1230 * out.
1231 */
1234 }
1236 /*
1237 * Does it conflict with some previously inherited column?
1238 */
1241 {
1242 Oid defTypeId;
1243 int32 deftypmod;
1245 /*
1246 * Yes, try to merge the two column definitions. They must
1247 * have the same type and typmod.
1248 */
1251 attributeName)));
1259 attributeName),
1264 /* Merge of NOT NULL constraints = OR 'em together */
1266 /* Default and other constraints are handled below */
1268 }
1269 else
1270 {
1271 /*
1272 * No, create a new inherited column
1273 */
1286 }
1288 /*
1289 * Copy default if any
1290 */
1292 {
1297 /* Find default in constraint structure */
1301 {
1303 {
1306 }
1307 }
1310 /*
1311 * If default expr could contain any vars, we'd need to fix
1312 * 'em, but it can't; so default is ready to apply to child.
1313 *
1314 * If we already had a default from some prior parent, check
1315 * to see if they are the same. If so, no problem; if not,
1316 * mark the column as having a bogus default. Below, we will
1317 * complain if the bogus default isn't overridden by the child
1318 * schema.
1319 */
1324 {
1327 }
1328 }
1329 }
1331 /*
1332 * Now copy the CHECK constraints of this parent, adjusting attnos
1333 * using the completed newattno[] map. Identically named constraints
1334 * are merged if possible, else we throw error.
1335 */
1337 {
1342 {
1346 /* adjust varattnos of ccbin here */
1350 /* check for duplicate */
1352 {
1353 /* nope, this is a new one */
1364 }
1365 }
1366 }
1370 /*
1371 * Close the parent rel, but keep our AccessShareLock on it until xact
1372 * commit. That will prevent someone else from deleting or ALTERing
1373 * the parent before the child is committed.
1374 */
1376 }
1378 /*
1379 * If we had no inherited attributes, the result schema is just the
1380 * explicitly declared columns. Otherwise, we need to merge the declared
1381 * columns into the inherited schema list.
1382 */
1384 {
1386 {
1391 /*
1392 * Does it conflict with some previously inherited column?
1393 */
1396 {
1398 Oid defTypeId,
1399 newTypeId;
1400 int32 deftypmod,
1401 newtypmod;
1403 /*
1404 * Yes, try to merge the two column definitions. They must
1405 * have the same type and typmod.
1406 */
1409 attributeName)));
1417 attributeName),
1421 /* Mark the column as locally defined */
1423 /* Merge of NOT NULL constraints = OR 'em together */
1425 /* If new def has a default, override previous default */
1427 {
1430 }
1431 }
1432 else
1433 {
1434 /*
1435 * No, attach new column to result schema
1436 */
1438 }
1439 }
1443 /*
1444 * Check that we haven't exceeded the legal # of columns after merging
1445 * in inherited columns.
1446 */
1451 MaxHeapAttributeNumber)));
1452 }
1454 /*
1455 * If we found any conflicting parent default values, check to make sure
1456 * they were overridden by the child.
1457 */
1459 {
1461 {
1470 }
1471 }
1477 }
1480 /*
1481 * MergeCheckConstraint
1482 * Try to merge an inherited CHECK constraint with previous ones
1483 *
1484 * If we inherit identically-named constraints from multiple parents, we must
1485 * merge them, or throw an error if they don't have identical definitions.
1486 *
1487 * constraints is a list of CookedConstraint structs for previous constraints.
1488 *
1489 * Returns TRUE if merged (constraint is a duplicate), or FALSE if it's
1490 * got a so-far-unique name, or throws error if conflict.
1491 */
1492 static bool
1494 {
1498 {
1503 /* Non-matching names never conflict */
1508 {
1509 /* OK to merge */
1512 }
1517 name)));
1518 }
1521 }
1524 /*
1525 * Replace varattno values in an expression tree according to the given
1526 * map array, that is, varattno N is replaced by newattno[N-1]. It is
1527 * caller's responsibility to ensure that the array is long enough to
1528 * define values for all user varattnos present in the tree. System column
1529 * attnos remain unchanged.
1530 *
1531 * Note that the passed node tree is modified in-place!
1532 */
1533 void
1535 {
1536 /* no setup needed, so away we go */
1538 }
1540 static bool
1542 {
1546 {
1551 {
1552 /*
1553 * ??? the following may be a problem when the node is multiply
1554 * referenced though stringToNode() doesn't create such a node
1555 * currently.
1556 */
1559 }
1561 }
1564 }
1566 /*
1567 * Generate a map for change_varattnos_of_a_node from old and new TupleDesc's,
1568 * matching according to column name.
1569 */
1570 AttrNumber *
1572 {
1575 j;
1579 {
1584 {
1587 {
1590 }
1591 }
1592 }
1594 }
1596 /*
1597 * Generate a map for change_varattnos_of_a_node from a TupleDesc and a list
1598 * of ColumnDefs
1599 */
1600 AttrNumber *
1602 {
1608 {
1613 schema);
1614 }
1616 }
1619 /*
1620 * StoreCatalogInheritance
1621 * Updates the system catalogs with proper inheritance information.
1622 *
1623 * supers is a list of the OIDs of the new relation's direct ancestors.
1624 */
1625 static void
1627 {
1628 Relation relation;
1629 int16 seqNumber;
1632 /*
1633 * sanity checks
1634 */
1640 /*
1641 * Store INHERITS information in pg_inherits using direct ancestors only.
1642 * Also enter dependencies on the direct ancestors, and make sure they are
1643 * marked with relhassubclass = true.
1644 *
1645 * (Once upon a time, both direct and indirect ancestors were found here
1646 * and then entered into pg_ipl. Since that catalog doesn't exist
1647 * anymore, there's no need to look for indirect ancestors.)
1648 */
1653 {
1657 seqNumber++;
1658 }
1661 }
1663 /*
1664 * Make catalog entries showing relationId as being an inheritance child
1665 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
1666 */
1667 static void
1670 {
1674 ObjectAddress childobject,
1675 parentobject;
1676 HeapTuple tuple;
1678 /*
1679 * Make the pg_inherits entry
1680 */
1697 /*
1698 * Store a dependency too
1699 */
1709 /*
1710 * Mark the parent as having subclasses.
1711 */
1713 }
1715 /*
1716 * Look for an existing schema entry with the given name.
1717 *
1718 * Returns the index (starting with 1) if attribute already exists in schema,
1719 * 0 if it doesn't.
1720 */
1721 static int
1723 {
1728 {
1734 i++;
1735 }
1737 }
1739 /*
1740 * Update a relation's pg_class.relhassubclass entry to the given value
1741 */
1742 static void
1744 {
1745 Relation relationRelation;
1746 HeapTuple tuple;
1747 Form_pg_class classtuple;
1749 /*
1750 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
1751 *
1752 * If the tuple already has the right relhassubclass setting, we don't
1753 * need to update it, but we still need to issue an SI inval message.
1754 */
1764 {
1768 /* keep the catalog indexes up to date */
1770 }
1771 else
1772 {
1773 /* no need to change tuple, but force relcache rebuild anyway */
1775 }
1779 }
1782 /*
1783 * renameatt - changes the name of a attribute in a relation
1784 *
1785 * Attname attribute is changed in attribute catalog.
1786 * No record of the previous attname is kept (correct?).
1787 *
1788 * get proper relrelation from relation catalog (if not arg)
1789 * scan attribute catalog
1790 * for name conflict (within rel)
1791 * for original attribute (if not arg)
1792 * modify attname in attribute tuple
1793 * insert modified attribute in attribute catalog
1794 * delete original attribute from attribute catalog
1795 */
1796 void
1802 {
1803 Relation targetrelation;
1804 Relation attrelation;
1805 HeapTuple atttup;
1806 Form_pg_attribute attform;
1811 /*
1812 * Grab an exclusive lock on the target table, which we will NOT release
1813 * until end of transaction.
1814 */
1817 /*
1818 * permissions checking. this would normally be done in utility.c, but
1819 * this particular routine is recursive.
1820 *
1821 * normally, only the owner of a class can change its schema.
1822 */
1832 /*
1833 * if the 'recurse' flag is set then we are supposed to rename this
1834 * attribute in all classes that inherit from 'relname' (as well as in
1835 * 'relname').
1836 *
1837 * any permissions or problems with duplicate attributes will cause the
1838 * whole transaction to abort, which is what we want -- all or nothing.
1839 */
1841 {
1845 /* this routine is actually in the planner */
1848 /*
1849 * find_all_inheritors does the recursive search of the inheritance
1850 * hierarchy, so all we have to do is process all of the relids in the
1851 * list that it returns.
1852 */
1854 {
1859 /* note we need not recurse again */
1861 }
1862 }
1863 else
1864 {
1865 /*
1866 * If we are told not to recurse, there had better not be any child
1867 * tables; else the rename would put them out of step.
1868 */
1874 oldattname)));
1875 }
1884 oldattname)));
1892 oldattname)));
1894 /*
1895 * if the attribute is inherited, forbid the renaming, unless we are
1896 * already inside a recursive rename.
1897 */
1902 oldattname)));
1904 /* should not already exist */
1905 /* this test is deliberately not attisdropped-aware */
1919 /* keep system catalog indexes current */
1924 /*
1925 * Update column names of indexes that refer to the column being renamed.
1926 */
1930 {
1932 HeapTuple indextup;
1933 Form_pg_index indexform;
1936 /*
1937 * Scan through index columns to see if there's any simple index
1938 * entries for this attribute. We ignore expressional entries.
1939 */
1948 {
1952 /*
1953 * Found one, rename it.
1954 */
1962 /*
1963 * Update the (copied) attribute tuple.
1964 */
1966 newattname);
1970 /* keep system catalog indexes current */
1974 }
1977 }
1984 }
1987 /*
1988 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW RENAME
1989 *
1990 * Caller has already done permissions checks.
1991 */
1992 void
1994 {
1995 Relation targetrelation;
1996 Oid namespaceId;
1999 /*
2000 * Grab an exclusive lock on the target table, index, sequence or view,
2001 * which we will NOT release until end of transaction.
2002 */
2008 /*
2009 * For compatibility with prior releases, we don't complain if ALTER TABLE
2010 * or ALTER INDEX is used to rename a sequence or view.
2011 */
2024 /*
2025 * Don't allow ALTER TABLE on composite types.
2026 * We want people to use ALTER TYPE for that.
2027 */
2035 /* Do the work */
2038 /*
2039 * Close rel, but keep exclusive lock!
2040 */
2042 }
2044 /*
2045 * RenameRelationInternal - change the name of a relation
2046 *
2047 * XXX - When renaming sequences, we don't bother to modify the
2048 * sequence name that is stored within the sequence itself
2049 * (this would cause problems with MVCC). In the future,
2050 * the sequence name should probably be removed from the
2051 * sequence, AFAIK there's no need for it to be there.
2052 */
2053 void
2055 {
2056 Relation targetrelation;
2058 HeapTuple reltup;
2059 Form_pg_class relform;
2061 /*
2062 * Grab an exclusive lock on the target table, index, sequence or
2063 * view, which we will NOT release until end of transaction.
2064 */
2067 /*
2068 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
2069 */
2083 newrelname)));
2085 /*
2086 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
2087 * because it's a copy...)
2088 */
2093 /* keep the system catalog indexes current */
2099 /*
2100 * Also rename the associated type, if any.
2101 */
2106 /*
2107 * Also rename the associated constraint, if any.
2108 */
2110 {
2115 }
2117 /*
2118 * Close rel, but keep exclusive lock!
2119 */
2121 }
2123 /*
2124 * Disallow ALTER TABLE (and similar commands) when the current backend has
2125 * any open reference to the target table besides the one just acquired by
2126 * the calling command; this implies there's an open cursor or active plan.
2127 * We need this check because our AccessExclusiveLock doesn't protect us
2128 * against stomping on our own foot, only other people's feet!
2129 *
2130 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
2131 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
2132 * possibly be relaxed to only error out for certain types of alterations.
2133 * But the use-case for allowing any of these things is not obvious, so we
2134 * won't work hard at it for now.
2135 *
2136 * We also reject these commands if there are any pending AFTER trigger events
2137 * for the rel. This is certainly necessary for the rewriting variants of
2138 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
2139 * events would try to fetch the wrong tuples. It might be overly cautious
2140 * in other cases, but again it seems better to err on the side of paranoia.
2141 *
2142 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
2143 * we are worried about active indexscans on the index. The trigger-event
2144 * check can be skipped, since we are doing no damage to the parent table.
2145 *
2146 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
2147 */
2148 void
2150 {
2157 /* translator: first %s is a SQL command, eg ALTER TABLE */
2166 /* translator: first %s is a SQL command, eg ALTER TABLE */
2170 }
2172 /*
2173 * AlterTable
2174 * Execute ALTER TABLE, which can be a list of subcommands
2175 *
2176 * ALTER TABLE is performed in three phases:
2177 * 1. Examine subcommands and perform pre-transformation checking.
2178 * 2. Update system catalogs.
2179 * 3. Scan table(s) to check new constraints, and optionally recopy
2180 * the data into new table(s).
2181 * Phase 3 is not performed unless one or more of the subcommands requires
2182 * it. The intention of this design is to allow multiple independent
2183 * updates of the table schema to be performed with only one pass over the
2184 * data.
2185 *
2186 * ATPrepCmd performs phase 1. A "work queue" entry is created for
2187 * each table to be affected (there may be multiple affected tables if the
2188 * commands traverse a table inheritance hierarchy). Also we do preliminary
2189 * validation of the subcommands, including parse transformation of those
2190 * expressions that need to be evaluated with respect to the old table
2191 * schema.
2192 *
2193 * ATRewriteCatalogs performs phase 2 for each affected table. (Note that
2194 * phases 2 and 3 normally do no explicit recursion, since phase 1 already
2195 * did it --- although some subcommands have to recurse in phase 2 instead.)
2196 * Certain subcommands need to be performed before others to avoid
2197 * unnecessary conflicts; for example, DROP COLUMN should come before
2198 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
2199 * lists, one for each logical "pass" of phase 2.
2200 *
2201 * ATRewriteTables performs phase 3 for those tables that need it.
2202 *
2203 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
2204 * the whole operation; we don't have to do anything special to clean up.
2205 */
2206 void
2208 {
2213 /* Check relation type against type specified in the ALTER command */
2215 {
2217 /*
2218 * For mostly-historical reasons, we allow ALTER TABLE to apply
2219 * to all relation types.
2220 */
2249 }
2252 }
2254 /*
2255 * AlterTableInternal
2256 *
2257 * ALTER TABLE with target specified by OID
2258 *
2259 * We do not reject if the relation is already open, because it's quite
2260 * likely that one or more layers of caller have it open. That means it
2261 * is unsafe to use this entry point for alterations that could break
2262 * existing query plans. On the assumption it's not used for such, we
2263 * don't have to reject pending AFTER triggers, either.
2264 */
2265 void
2267 {
2271 }
2273 static void
2275 {
2279 /* Phase 1: preliminary examination of commands, create work queue */
2281 {
2285 }
2287 /* Close the relation, but keep lock until commit */
2290 /* Phase 2: update system catalogs */
2293 /* Phase 3: scan/rewrite tables as needed */
2295 }
2297 /*
2298 * ATPrepCmd
2299 *
2300 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
2301 * recursion and permission checks.
2302 *
2303 * Caller must have acquired AccessExclusiveLock on relation already.
2304 * This lock should be held until commit.
2305 */
2306 static void
2309 {
2313 /* Find or create work queue entry for this table */
2316 /*
2317 * Copy the original subcommand for each table. This avoids conflicts
2318 * when different child tables need to make different parse
2319 * transformations (for example, the same column may have different column
2320 * numbers in different children).
2321 */
2324 /*
2325 * Do permissions checking, recursion to child tables if needed, and any
2326 * additional phase-1 processing needed.
2327 */
2329 {
2332 /* Performs own recursion */
2338 /*
2339 * We allow defaults on views so that INSERT into a view can have
2340 * default-ish behavior. This works because the rewriter
2341 * substitutes default values into INSERTs before it expands
2342 * rules.
2343 */
2346 /* No command-specific prep needed */
2352 /* No command-specific prep needed */
2358 /* No command-specific prep needed */
2363 /* Performs own permission checks */
2370 /* No command-specific prep needed */
2375 /* Recursion occurs during execution phase */
2376 /* No command-specific prep needed except saving recurse flag */
2383 /* This command never recurses */
2384 /* No command-specific prep needed */
2389 /* Recursion occurs during execution phase */
2390 /* No command-specific prep needed except saving recurse flag */
2397 /* Recursion occurs during execution phase */
2398 /* No command-specific prep needed except saving recurse flag */
2405 /* Performs own recursion */
2410 /* This command never recurses */
2411 /* No command-specific prep needed */
2417 /* These commands never recurse */
2418 /* No command-specific prep needed */
2423 /* Performs own recursion */
2425 {
2432 }
2437 /* This command never recurses */
2444 /* This command never recurses */
2445 /* No command-specific prep needed */
2463 /* These commands never recurse */
2464 /* No command-specific prep needed */
2472 }
2474 /* Add the subcommand to the appropriate list for phase 2 */
2476 }
2478 /*
2479 * ATRewriteCatalogs
2480 *
2481 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
2482 * dispatched in a "safe" execution order (designed to avoid unnecessary
2483 * conflicts).
2484 */
2485 static void
2487 {
2491 /*
2492 * We process all the tables "in parallel", one pass at a time. This is
2493 * needed because we may have to propagate work from one table to another
2494 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
2495 * re-adding of the foreign key constraint to the other table). Work can
2496 * only be propagated into later passes, however.
2497 */
2499 {
2500 /* Go through each table that needs to be processed */
2502 {
2505 Relation rel;
2511 /*
2512 * Exclusive lock was obtained by phase 1, needn't get it again
2513 */
2519 /*
2520 * After the ALTER TYPE pass, do cleanup work (this is not done in
2521 * ATExecAlterColumnType since it should be done only once if
2522 * multiple columns of a table are altered).
2523 */
2528 }
2529 }
2531 /*
2532 * Check to see if a toast table must be added, if we executed any
2533 * subcommands that might have added a column or changed column storage.
2534 */
2536 {
2544 }
2545 }
2547 /*
2548 * ATExecCmd: dispatch a subcommand to appropriate execution routine
2549 */
2550 static void
2553 {
2555 {
2614 /*
2615 * Nothing to do here; we'll have generated a DropColumn
2616 * subcommand to do the real work
2617 */
2621 /*
2622 * Nothing to do here; Phase 3 does the work
2623 */
2667 RULE_FIRES_ON_ORIGIN);
2671 RULE_FIRES_ALWAYS);
2675 RULE_FIRES_ON_REPLICA);
2679 RULE_DISABLED);
2692 }
2694 /*
2695 * Bump the command counter to ensure the next subcommand in the sequence
2696 * can see the changes so far
2697 */
2699 }
2701 /*
2702 * ATRewriteTables: ALTER TABLE phase 3
2703 */
2704 static void
2706 {
2709 /* Go through each table that needs to be checked or rewritten */
2711 {
2714 /*
2715 * We only need to rewrite the table if at least one column needs to
2716 * be recomputed.
2717 */
2719 {
2720 /* Build a temporary relation and copy data */
2721 Oid OIDNewHeap;
2723 Oid NewTableSpace;
2724 Relation OldHeap;
2725 ObjectAddress object;
2729 /*
2730 * We can never allow rewriting of shared or nailed-in-cache
2731 * relations, because we can't support changing their relfilenode
2732 * values.
2733 */
2740 /*
2741 * Don't allow rewrite on temp tables of other backends ... their
2742 * local buffer manager is not going to cope.
2743 */
2749 /*
2750 * Select destination tablespace (same as original unless user
2751 * requested a change)
2752 */
2755 else
2760 /*
2761 * Create the new heap, using a temporary name in the same
2762 * namespace as the existing table. NOTE: there is some risk of
2763 * collision with user relnames. Working around this seems more
2764 * trouble than it's worth; in particular, we can't create the new
2765 * heap in a different namespace from the old, or we will have
2766 * problems with the TEMP status of temp tables.
2767 */
2773 /*
2774 * Copy the heap data into the new table with the desired
2775 * modifications, and test the current data within the table
2776 * against new constraints generated by ALTER TABLE commands.
2777 */
2780 /*
2781 * Swap the physical files of the old and new heaps. Since we are
2782 * generating a new heap, we can use RecentXmin for the table's
2783 * new relfrozenxid because we rewrote all the tuples on
2784 * ATRewriteTable, so no older Xid remains on the table.
2785 */
2790 /* Destroy new heap with old filenode */
2795 /*
2796 * The new relation is local to our transaction and we know
2797 * nothing depends on it, so DROP_RESTRICT should be OK.
2798 */
2800 /* performDeletion does CommandCounterIncrement at end */
2802 /*
2803 * Rebuild each index on the relation (but not the toast table,
2804 * which is all-new anyway). We do not need
2805 * CommandCounterIncrement() because reindex_relation does it.
2806 */
2808 }
2809 else
2810 {
2811 /*
2812 * Test the current data within the table against new constraints
2813 * generated by ALTER TABLE commands, but don't rebuild data.
2814 */
2818 /*
2819 * If we had SET TABLESPACE but no reason to reconstruct tuples,
2820 * just do a block-by-block copy.
2821 */
2824 }
2825 }
2827 /*
2828 * Foreign key constraints are checked in a final pass, since (a) it's
2829 * generally best to examine each one separately, and (b) it's at least
2830 * theoretically possible that we have changed both relations of the
2831 * foreign key, and we'd better have finished both rewrites before we try
2832 * to read the tables.
2833 */
2835 {
2841 {
2845 {
2847 Relation refrel;
2850 {
2851 /* Long since locked, no need for another */
2853 }
2861 }
2862 }
2866 }
2867 }
2869 /*
2870 * ATRewriteTable: scan or rewrite one table
2871 *
2872 * OIDNewHeap is InvalidOid if we don't need to rewrite
2873 */
2874 static void
2876 {
2877 Relation oldrel;
2878 Relation newrel;
2879 TupleDesc oldTupDesc;
2880 TupleDesc newTupDesc;
2887 /*
2888 * Open the relation(s). We have surely already locked the existing
2889 * table.
2890 */
2897 else
2900 /*
2901 * If we need to rewrite the table, the operation has to be propagated to
2902 * tables that use this table's rowtype as a column type.
2903 *
2904 * (Eventually this will probably become true for scans as well, but at
2905 * the moment a composite type does not enforce any constraints, so it's
2906 * not necessary/appropriate to enforce them just during ALTER.)
2907 */
2911 NULL);
2913 /*
2914 * Generate the constraint and default execution states
2915 */
2919 /* Build the needed expression execution states */
2921 {
2925 {
2932 /* Nothing to do here */
2937 }
2938 }
2941 {
2947 }
2951 {
2952 /*
2953 * If we are rebuilding the tuples OR if we added any new NOT NULL
2954 * constraints, check all not-null constraints. This is a bit of
2955 * overkill but it minimizes risk of bugs, and heap_attisnull is a
2956 * pretty cheap test anyway.
2957 */
2959 {
2963 }
2966 }
2969 {
2975 HeapScanDesc scan;
2976 HeapTuple tuple;
2977 MemoryContext oldCxt;
2983 /*
2984 * Make tuple slots for old and new tuples. Note that even when the
2985 * tuples are the same, the tupDescs might not be (consider ADD COLUMN
2986 * without a default).
2987 */
2991 /* Preallocate values/isnull arrays */
2998 /*
2999 * Any attributes that are dropped according to the new tuple
3000 * descriptor can be set to NULL. We precompute the list of dropped
3001 * attributes to avoid needing to do so in the per-tuple loop.
3002 */
3004 {
3007 }
3009 /*
3010 * Scan through the rows, generating a new row if needed and then
3011 * checking all the constraints.
3012 */
3015 /*
3016 * Switch to per-tuple memory context and reset it for each tuple
3017 * produced, so we don't leak memory.
3018 */
3022 {
3024 {
3027 /* Extract data from old tuple */
3032 /* Set dropped attributes to null in new tuple */
3036 /*
3037 * Process supplied expressions to replace selected columns.
3038 * Expression inputs come from the old tuple.
3039 */
3044 {
3048 econtext,
3050 NULL);
3051 }
3053 /*
3054 * Form the new tuple. Note that we don't explicitly pfree it,
3055 * since the per-tuple memory context will be reset shortly.
3056 */
3059 /* Preserve OID, if any */
3062 }
3064 /* Now check any constraints on the possibly-changed tuple */
3069 {
3077 }
3080 {
3084 {
3093 /* Nothing to do here */
3098 }
3099 }
3101 /* Write the tuple out to the new relation */
3108 }
3115 }
3122 }
3124 /*
3125 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
3126 */
3129 {
3135 {
3139 }
3141 /*
3142 * Not there, so add it. Note that we make a copy of the relation's
3143 * existing descriptor before anything interesting can happen to it.
3144 */
3153 }
3155 /*
3156 * ATSimplePermissions
3157 *
3158 * - Ensure that it is a relation (or possibly a view)
3159 * - Ensure this user is the owner
3160 * - Ensure that it is not a system table
3161 */
3162 static void
3164 {
3166 {
3168 {
3174 }
3175 else
3180 }
3182 /* Permissions checks */
3192 }
3194 /*
3195 * ATSimplePermissionsRelationOrIndex
3196 *
3197 * - Ensure that it is a relation or an index
3198 * - Ensure this user is the owner
3199 * - Ensure that it is not a system table
3200 */
3201 static void
3203 {
3211 /* Permissions checks */
3221 }
3223 /*
3224 * ATSimpleRecursion
3225 *
3226 * Simple table recursion sufficient for most ALTER TABLE operations.
3227 * All direct and indirect children are processed in an unspecified order.
3228 * Note that if a child inherits from the original table via multiple
3229 * inheritance paths, it will be visited just once.
3230 */
3231 static void
3234 {
3235 /*
3236 * Propagate to children if desired. Non-table relations never have
3237 * children, so no need to search in that case.
3238 */
3240 {
3245 /* this routine is actually in the planner */
3248 /*
3249 * find_all_inheritors does the recursive search of the inheritance
3250 * hierarchy, so all we have to do is process all of the relids in the
3251 * list that it returns.
3252 */
3254 {
3256 Relation childrel;
3264 }
3265 }
3266 }
3268 /*
3269 * ATOneLevelRecursion
3270 *
3271 * Here, we visit only direct inheritance children. It is expected that
3272 * the command's prep routine will recurse again to find indirect children.
3273 * When using this technique, a multiply-inheriting child will be visited
3274 * multiple times.
3275 */
3276 static void
3279 {
3284 /* this routine is actually in the planner */
3288 {
3290 Relation childrel;
3296 }
3297 }
3300 /*
3301 * find_composite_type_dependencies
3302 *
3303 * Check to see if a composite type is being used as a column in some
3304 * other table (possibly nested several levels deep in composite types!).
3305 * Eventually, we'd like to propagate the check or rewrite operation
3306 * into other such tables, but for now, just error out if we find any.
3307 *
3308 * Caller should provide either a table name or a type name (not both) to
3309 * report in the error message, if any.
3310 *
3311 * We assume that functions and views depending on the type are not reasons
3312 * to reject the ALTER. (How safe is this really?)
3313 */
3314 void
3318 {
3319 Relation depRel;
3321 SysScanDesc depScan;
3322 HeapTuple depTup;
3323 Oid arrayOid;
3325 /*
3326 * We scan pg_depend to find those things that depend on the rowtype. (We
3327 * assume we can ignore refobjsubid for a rowtype.)
3328 */
3332 Anum_pg_depend_refclassid,
3336 Anum_pg_depend_refobjid,
3344 {
3346 Relation rel;
3347 Form_pg_attribute att;
3349 /* Ignore dependees that aren't user columns of relations */
3350 /* (we assume system columns are never of rowtypes) */
3359 {
3364 origTblName,
3367 else
3371 origTypeName,
3374 }
3376 {
3377 /*
3378 * A view or composite type itself isn't a problem, but we must
3379 * recursively check for indirect dependencies via its rowtype.
3380 */
3383 }
3386 }
3392 /*
3393 * If there's an array type for the rowtype, must check for uses of it,
3394 * too.
3395 */
3399 }
3402 /*
3403 * ALTER TABLE ADD COLUMN
3404 *
3405 * Adds an additional attribute to a relation making the assumption that
3406 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
3407 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
3408 * AlterTableCmd's.
3409 */
3410 static void
3413 {
3414 /*
3415 * Recurse to add the column to child classes, if requested.
3416 *
3417 * We must recurse one level at a time, so that multiply-inheriting
3418 * children are visited the right number of times and end up with the
3419 * right attinhcount.
3420 */
3422 {
3426 /* Child should see column as singly inherited */
3431 }
3432 else
3433 {
3434 /*
3435 * If we are told not to recurse, there had better not be any child
3436 * tables; else the addition would put them out of step.
3437 */
3442 }
3443 }
3445 static void
3448 {
3450 Relation pgclass,
3451 attrdesc;
3452 HeapTuple reltup;
3453 HeapTuple attributeTuple;
3454 Form_pg_attribute attribute;
3455 FormData_pg_attribute attributeD;
3458 maxatts;
3459 HeapTuple typeTuple;
3460 Oid typeOid;
3461 int32 typmod;
3462 Form_pg_type tform;
3467 /*
3468 * Are we adding the column to a recursion child? If so, check whether to
3469 * merge with an existing definition for the column.
3470 */
3472 {
3473 HeapTuple tuple;
3475 /* Does child already have a column by this name? */
3478 {
3480 Oid ctypeId;
3481 int32 ctypmod;
3483 /* Okay if child matches by type */
3492 /* Bump the existing child att's inhcount */
3499 /* Inform the user about the merge */
3506 }
3507 }
3517 /*
3518 * this test is deliberately not attisdropped-aware, since if one tries to
3519 * add a column matching a dropped column name, it's gonna fail anyway.
3520 */
3536 MaxHeapAttributeNumber)));
3543 /* make sure datatype is legal for a column */
3548 ATTRIBUTE_TUPLE_SIZE,
3575 /* Update indexes on pg_attribute */
3580 /*
3581 * Update number of attributes in pg_class tuple
3582 */
3587 /* keep catalog indexes current */
3594 /* Make the attribute's catalog entry visible */
3597 /*
3598 * Store the DEFAULT, if any, in the catalogs
3599 */
3601 {
3608 /*
3609 * This function is intended for CREATE TABLE, so it processes a
3610 * _list_ of defaults, but we just do one.
3611 */
3614 /* Make the additional catalog changes visible */
3616 }
3618 /*
3619 * Tell Phase 3 to fill in the default expression, if there is one.
3620 *
3621 * If there is no default, Phase 3 doesn't have to do anything, because
3622 * that effectively means that the default is NULL. The heap tuple access
3623 * routines always check for attnum > # of attributes in tuple, and return
3624 * NULL if so, so without any modification of the tuple data we will get
3625 * the effect of NULL values in the new column.
3626 *
3627 * An exception occurs when the new column is of a domain type: the domain
3628 * might have a NOT NULL constraint, or a check constraint that indirectly
3629 * rejects nulls. If there are any domain constraints then we construct
3630 * an explicit NULL default value that will be passed through
3631 * CoerceToDomain processing. (This is a tad inefficient, since it causes
3632 * rewriting the table which we really don't have to do, but the present
3633 * design of domain processing doesn't offer any simple way of checking
3634 * the constraints more directly.)
3635 *
3636 * Note: we use build_column_default, and not just the cooked default
3637 * returned by AddRelationNewConstraints, so that the right thing happens
3638 * when a datatype's default applies.
3639 */
3643 {
3644 Oid baseTypeId;
3645 int32 baseTypeMod;
3652 baseTypeId,
3653 typeOid,
3654 typmod,
3655 COERCION_ASSIGNMENT,
3656 COERCE_IMPLICIT_CAST,
3660 }
3663 {
3671 }
3673 /*
3674 * If the new column is NOT NULL, tell Phase 3 it needs to test that.
3675 */
3678 /*
3679 * Add needed dependency entries for the new column.
3680 */
3682 }
3684 /*
3685 * Install a column's dependency on its datatype.
3686 */
3687 static void
3689 {
3690 ObjectAddress myself,
3691 referenced;
3700 }
3702 /*
3703 * ALTER TABLE ALTER COLUMN DROP NOT NULL
3704 */
3705 static void
3707 {
3708 HeapTuple tuple;
3709 AttrNumber attnum;
3710 Relation attr_rel;
3714 /*
3715 * lookup the attribute
3716 */
3729 /* Prevent them from altering a system attribute */
3734 colName)));
3736 /*
3737 * Check that the attribute is not in a primary key
3738 */
3740 /* Loop over all indexes on the relation */
3744 {
3746 HeapTuple indexTuple;
3747 Form_pg_index indexStruct;
3757 /* If the index is not a primary key, skip the check */
3759 {
3760 /*
3761 * Loop over each attribute in the primary key and see if it
3762 * matches the to-be-altered attribute
3763 */
3765 {
3770 colName)));
3771 }
3772 }
3775 }
3779 /*
3780 * Okay, actually perform the catalog change ... if needed
3781 */
3783 {
3788 /* keep the system catalog indexes current */
3790 }
3793 }
3795 /*
3796 * ALTER TABLE ALTER COLUMN SET NOT NULL
3797 */
3798 static void
3801 {
3802 HeapTuple tuple;
3803 AttrNumber attnum;
3804 Relation attr_rel;
3806 /*
3807 * lookup the attribute
3808 */
3821 /* Prevent them from altering a system attribute */
3826 colName)));
3828 /*
3829 * Okay, actually perform the catalog change ... if needed
3830 */
3832 {
3837 /* keep the system catalog indexes current */
3840 /* Tell Phase 3 it needs to test the constraint */
3842 }
3845 }
3847 /*
3848 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
3849 */
3850 static void
3853 {
3854 AttrNumber attnum;
3856 /*
3857 * get the number of the attribute
3858 */
3866 /* Prevent them from altering a system attribute */
3871 colName)));
3873 /*
3874 * Remove any old default for the column. We use RESTRICT here for
3875 * safety, but at present we do not expect anything to depend on the
3876 * default.
3877 */
3881 {
3882 /* SET DEFAULT */
3889 /*
3890 * This function is intended for CREATE TABLE, so it processes a
3891 * _list_ of defaults, but we just do one.
3892 */
3894 }
3895 }
3897 /*
3898 * ALTER TABLE ALTER COLUMN SET STATISTICS
3899 */
3900 static void
3902 {
3903 /*
3904 * We do our own permission checking because (a) we want to allow SET
3905 * STATISTICS on indexes (for expressional index columns), and (b) we want
3906 * to allow SET STATISTICS on system catalogs without requiring
3907 * allowSystemTableMods to be turned on.
3908 */
3916 /* Permissions checks */
3920 }
3922 static void
3924 {
3926 Relation attrelation;
3927 HeapTuple tuple;
3928 Form_pg_attribute attrtuple;
3933 /*
3934 * Limit target to a sane range
3935 */
3937 {
3941 newtarget)));
3942 }
3944 {
3949 newtarget)));
3950 }
3967 colName)));
3973 /* keep system catalog indexes current */
3979 }
3981 /*
3982 * ALTER TABLE ALTER COLUMN SET STORAGE
3983 */
3984 static void
3986 {
3989 Relation attrelation;
3990 HeapTuple tuple;
3991 Form_pg_attribute attrtuple;
4004 else
4005 {
4009 storagemode)));
4011 }
4028 colName)));
4030 /*
4031 * safety check: do not allow toasted storage modes unless column datatype
4032 * is TOAST-aware.
4033 */
4036 else
4044 /* keep system catalog indexes current */
4050 }
4053 /*
4054 * ALTER TABLE DROP COLUMN
4055 *
4056 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
4057 * because we have to decide at runtime whether to recurse or not depending
4058 * on whether attinhcount goes to zero or not. (We can't check this in a
4059 * static pre-pass because it won't handle multiple inheritance situations
4060 * correctly.) Since DROP COLUMN doesn't need to create any work queue
4061 * entries for Phase 3, it's okay to recurse internally in this routine
4062 * without considering the work queue.
4063 */
4064 static void
4066 DropBehavior behavior,
4068 {
4069 HeapTuple tuple;
4070 Form_pg_attribute targetatt;
4071 AttrNumber attnum;
4073 ObjectAddress object;
4075 /* At top level, permission check was done in ATPrepCmd, else do it */
4079 /*
4080 * get the number of the attribute
4081 */
4092 /* Can't drop a system attribute, except OID */
4097 colName)));
4099 /* Don't drop inherited columns */
4104 colName)));
4108 /*
4109 * Propagate to children as appropriate. Unlike most other ALTER
4110 * routines, we have to do this one level of recursion at a time; we can't
4111 * use find_all_inheritors to do it in one pass.
4112 */
4116 {
4117 Relation attr_rel;
4122 {
4124 Relation childrel;
4125 Form_pg_attribute childatt;
4141 {
4142 /*
4143 * If the child column has other definition sources, just
4144 * decrement its inheritance count; if not, recurse to delete
4145 * it.
4146 */
4148 {
4149 /* Time to delete this child column, too */
4151 }
4152 else
4153 {
4154 /* Child column must survive my deletion */
4159 /* keep the system catalog indexes current */
4162 /* Make update visible */
4164 }
4165 }
4166 else
4167 {
4168 /*
4169 * If we were told to drop ONLY in this table (no recursion),
4170 * we need to mark the inheritors' attributes as locally
4171 * defined rather than inherited.
4172 */
4178 /* keep the system catalog indexes current */
4181 /* Make update visible */
4183 }
4188 }
4190 }
4192 /*
4193 * Perform the actual column deletion
4194 */
4201 /*
4202 * If we dropped the OID column, must adjust pg_class.relhasoids
4203 */
4205 {
4206 Relation class_rel;
4207 Form_pg_class tuple_class;
4222 /* Keep the catalog indexes up to date */
4226 }
4227 }
4229 /*
4230 * ALTER TABLE ADD INDEX
4231 *
4232 * There is no such command in the grammar, but parse_utilcmd.c converts
4233 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
4234 * us schedule creation of the index at the appropriate time during ALTER.
4235 */
4236 static void
4239 {
4246 /* suppress schema rights check when rebuilding existing index */
4248 /* skip index build if phase 3 will have to rewrite table anyway */
4250 /* suppress notices when rebuilding existing index */
4253 /* The IndexStmt has already been through transformIndexStmt */
4267 check_rights,
4268 skip_build,
4269 quiet,
4271 }
4273 /*
4274 * ALTER TABLE ADD CONSTRAINT
4275 */
4276 static void
4279 {
4281 {
4283 {
4286 /*
4287 * Currently, we only expect to see CONSTR_CHECK nodes
4288 * arriving here (see the preprocessing done in
4289 * parse_utilcmd.c). Use a switch anyway to make it easier to
4290 * add more code later.
4291 */
4293 {
4301 }
4303 }
4305 {
4308 /*
4309 * Note that we currently never recurse for FK constraints,
4310 * so the "recurse" flag is silently ignored.
4311 *
4312 * Assign or validate constraint name
4313 */
4315 {
4325 }
4326 else
4332 NIL);
4337 }
4341 }
4342 }
4344 /*
4345 * Add a check constraint to a single table and its children
4346 *
4347 * Subroutine for ATExecAddConstraint.
4348 *
4349 * We must recurse to child tables during execution, rather than using
4350 * ALTER TABLE's normal prep-time recursion. The reason is that all the
4351 * constraints *must* be given the same name, else they won't be seen as
4352 * related later. If the user didn't explicitly specify a name, then
4353 * AddRelationNewConstraints would normally assign different names to the
4354 * child constraints. To fix that, we must capture the name assigned at
4355 * the parent table and pass that down.
4356 */
4357 static void
4360 {
4366 /* At top level, permission check was done in ATPrepCmd, else do it */
4370 /*
4371 * Call AddRelationNewConstraints to do the work, making sure it works on
4372 * a copy of the Constraint so transformExpr can't modify the original.
4373 * It returns a list of cooked constraints.
4374 *
4375 * If the constraint ends up getting merged with a pre-existing one, it's
4376 * omitted from the returned list, which is what we want: we do not need
4377 * to do any validation work. That can only happen at child tables,
4378 * though, since we disallow merging at the top level.
4379 */
4384 /* Add each constraint to Phase 3's queue */
4386 {
4393 /* ExecQual wants implicit-AND format */
4398 /* Save the actually assigned name if it was defaulted */
4401 }
4403 /* At this point we must have a locked-down name to use */
4406 /* Advance command counter in case same table is visited multiple times */
4409 /*
4410 * Propagate to children as appropriate. Unlike most other ALTER
4411 * routines, we have to do this one level of recursion at a time; we can't
4412 * use find_all_inheritors to do it in one pass.
4413 */
4416 /*
4417 * If we are told not to recurse, there had better not be any child
4418 * tables; else the addition would put them out of step.
4419 */
4426 {
4428 Relation childrel;
4434 /* Find or create work queue entry for this table */
4437 /* Recurse to child */
4442 }
4443 }
4445 /*
4446 * Add a foreign-key constraint to a single table
4447 *
4448 * Subroutine for ATExecAddConstraint. Must already hold exclusive
4449 * lock on the rel, and have done appropriate validity/permissions checks
4450 * for it.
4451 */
4452 static void
4455 {
4456 Relation pkrel;
4457 AclResult aclresult;
4468 numpks;
4469 Oid indexOid;
4470 Oid constrOid;
4472 /*
4473 * Grab an exclusive lock on the pk table, so that someone doesn't delete
4474 * rows out from under us. (Although a lesser lock would do for that
4475 * purpose, we'll need exclusive lock anyway to add triggers to the pk
4476 * table; trying to start with a lesser lock will just create a risk of
4477 * deadlock.)
4478 */
4481 /*
4482 * Validity and permissions checks
4483 *
4484 * Note: REFERENCES permissions checks are redundant with CREATE TRIGGER,
4485 * but we may as well error out sooner instead of later.
4486 */
4494 ACL_REFERENCES);
4506 ACL_REFERENCES);
4511 /*
4512 * Disallow reference from permanent table to temp table or vice versa.
4513 * (The ban on perm->temp is for fairly obvious reasons. The ban on
4514 * temp->perm is because other backends might need to run the RI triggers
4515 * on the perm table, but they can't reliably see tuples the owning
4516 * backend has created in the temp table, because non-shared buffers are
4517 * used for temp tables.)
4518 */
4520 {
4525 }
4526 else
4527 {
4532 }
4534 /*
4535 * Look up the referencing attributes to make sure they exist, and record
4536 * their attnums and type OIDs.
4537 */
4551 /*
4552 * If the attribute list for the referenced table was omitted, lookup the
4553 * definition of the primary key and use it. Otherwise, validate the
4554 * supplied attribute list. In either case, discover the index OID and
4555 * index opclasses, and the attnums and type OIDs of the attributes.
4556 */
4558 {
4562 opclasses);
4563 }
4564 else
4565 {
4569 /* Look for an index matching the column list */
4571 opclasses);
4572 }
4574 /*
4575 * Look up the equality operators to use in the constraint.
4576 *
4577 * Note that we have to be careful about the difference between the actual
4578 * PK column type and the opclass' declared input type, which might be
4579 * only binary-compatible with it. The declared opcintype is the right
4580 * thing to probe pg_amop with.
4581 */
4588 {
4591 Oid fktyped;
4592 HeapTuple cla_ht;
4593 Form_pg_opclass cla_tup;
4594 Oid amid;
4595 Oid opfamily;
4596 Oid opcintype;
4597 Oid pfeqop;
4598 Oid ppeqop;
4599 Oid ffeqop;
4600 int16 eqstrategy;
4602 /* We need several fields out of the pg_opclass entry */
4614 /*
4615 * Check it's a btree; currently this can never fail since no other
4616 * index AMs support unique indexes. If we ever did have other types
4617 * of unique indexes, we'd need a way to determine which operator
4618 * strategy number is equality. (Is it reasonable to insist that
4619 * every such index AM use btree's number for equality?)
4620 */
4625 /*
4626 * There had better be a primary equality operator for the index.
4627 * We'll use it for PK = PK comparisons.
4628 */
4630 eqstrategy);
4636 /*
4637 * Are there equality operators that take exactly the FK type? Assume
4638 * we should look through any domain here.
4639 */
4643 eqstrategy);
4646 eqstrategy);
4647 else
4651 {
4652 /*
4653 * Otherwise, look for an implicit cast from the FK type to the
4654 * opcintype, and if found, use the primary equality operator.
4655 * This is a bit tricky because opcintype might be a polymorphic
4656 * type such as ANYARRAY or ANYENUM; so what we have to test is
4657 * whether the two actual column types can be concurrently cast to
4658 * that type. (Otherwise, we'd fail to reject combinations such
4659 * as int[] and point[].)
4660 */
4669 COERCION_IMPLICIT))
4671 }
4689 }
4691 /*
4692 * Record the FK constraint in pg_constraint.
4693 */
4696 CONSTRAINT_FOREIGN,
4700 fkattnum,
4701 numfks,
4703 * constraint */
4705 pkattnum,
4706 pfeqoperators,
4707 ppeqoperators,
4708 ffeqoperators,
4709 numpks,
4713 indexOid,
4715 NULL,
4716 NULL,
4720 /*
4721 * Create the triggers that will enforce the constraint.
4722 */
4725 /*
4726 * Tell Phase 3 to check that the constraint is satisfied by existing rows
4727 * (we can skip this during table creation).
4728 */
4730 {
4741 }
4743 /*
4744 * Close pk table, but keep lock until we've committed.
4745 */
4747 }
4750 /*
4751 * transformColumnNameList - transform list of column names
4752 *
4753 * Lookup each name and return its attnum and type OID
4754 */
4755 static int
4758 {
4764 {
4766 HeapTuple atttuple;
4773 attname)));
4778 INDEX_MAX_KEYS)));
4782 attnum++;
4783 }
4786 }
4788 /*
4789 * transformFkeyGetPrimaryKey -
4790 *
4791 * Look up the names, attnums, and types of the primary key attributes
4792 * for the pkrel. Also return the index OID and index opclasses of the
4793 * index supporting the primary key.
4794 *
4795 * All parameters except pkrel are output parameters. Also, the function
4796 * return value is the number of attributes in the primary key.
4797 *
4798 * Used when the column list in the REFERENCES specification is omitted.
4799 */
4800 static int
4805 {
4810 Datum indclassDatum;
4815 /*
4816 * Get the list of index OIDs for the table from the relcache, and look up
4817 * each one in the pg_index syscache until we find one marked primary key
4818 * (hopefully there isn't more than one such).
4819 */
4825 {
4835 {
4838 }
4840 }
4844 /*
4845 * Check that we found it
4846 */
4853 /* Must get indclass the hard way */
4859 /*
4860 * Now build the list of PK attributes from the indkey definition (we
4861 * assume a primary key cannot have expressional elements)
4862 */
4865 {
4873 }
4878 }
4880 /*
4881 * transformFkeyCheckAttrs -
4882 *
4883 * Make sure that the attributes of a referenced table belong to a unique
4884 * (or primary key) constraint. Return the OID of the index supporting
4885 * the constraint, as well as the opclasses associated with the index
4886 * columns.
4887 */
4888 static Oid
4892 {
4898 /*
4899 * Get the list of index OIDs for the table from the relcache, and look up
4900 * each one in the pg_index syscache, and match unique indexes to the list
4901 * of attnums we are given.
4902 */
4906 {
4907 HeapTuple indexTuple;
4908 Form_pg_index indexStruct;
4910 j;
4920 /*
4921 * Must have the right number of columns; must be unique and not a
4922 * partial index; forget it if there are any expressions, too
4923 */
4928 {
4929 /* Must get indclass the hard way */
4930 Datum indclassDatum;
4939 /*
4940 * The given attnum list may match the index columns in any order.
4941 * Check that each list is a subset of the other.
4942 */
4944 {
4947 {
4949 {
4952 }
4953 }
4956 }
4958 {
4960 {
4963 {
4965 {
4969 }
4970 }
4973 }
4974 }
4975 }
4979 }
4990 }
4992 /*
4993 * Scan the existing rows in a table to verify they meet a proposed FK
4994 * constraint.
4995 *
4996 * Caller must have opened and locked both relations.
4997 */
4998 static void
5000 Relation rel,
5001 Relation pkrel,
5002 Oid constraintOid)
5003 {
5004 HeapScanDesc scan;
5005 HeapTuple tuple;
5006 Trigger trig;
5008 /*
5009 * Build a trigger call structure; we'll need it either way.
5010 */
5020 /* we needn't fill in tgargs */
5022 /*
5023 * See if we can do it with a single LEFT JOIN query. A FALSE result
5024 * indicates we must proceed with the fire-the-trigger method.
5025 */
5029 /*
5030 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
5031 * if that tuple had just been inserted. If any of those fail, it should
5032 * ereport(ERROR) and that's that.
5033 */
5037 {
5038 FunctionCallInfoData fcinfo;
5039 TriggerData trigdata;
5041 /*
5042 * Make a call to the trigger function
5043 *
5044 * No parameters are passed, but we do set a context
5045 */
5048 /*
5049 * We assume RI_FKey_check_ins won't look at flinfo...
5050 */
5063 }
5066 }
5068 static void
5071 {
5080 /* Either ON INSERT or ON UPDATE */
5082 {
5085 }
5086 else
5087 {
5090 }
5101 /* Make changes-so-far visible */
5103 }
5105 /*
5106 * Create the triggers that implement an FK constraint.
5107 */
5108 static void
5110 Oid constraintOid)
5111 {
5115 /*
5116 * Reconstruct a RangeVar for my relation (not passed in, unfortunately).
5117 */
5122 /* Make changes-so-far visible */
5125 /*
5126 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the CHECK
5127 * action for both INSERTs and UPDATEs on the referencing table.
5128 */
5132 /*
5133 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
5134 * DELETE action on the referenced table.
5135 */
5147 {
5177 }
5182 /* Make changes-so-far visible */
5185 /*
5186 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
5187 * UPDATE action on the referenced table.
5188 */
5199 {
5229 }
5233 }
5235 /*
5236 * ALTER TABLE DROP CONSTRAINT
5237 *
5238 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
5239 */
5240 static void
5242 DropBehavior behavior,
5244 {
5247 Relation conrel;
5248 Form_pg_constraint con;
5249 SysScanDesc scan;
5250 ScanKeyData key;
5251 HeapTuple tuple;
5255 /* At top level, permission check was done in ATPrepCmd, else do it */
5261 /*
5262 * Find and drop the target constraint
5263 */
5265 Anum_pg_constraint_conrelid,
5272 {
5273 ObjectAddress conobj;
5280 /* Don't drop inherited constraints */
5287 /* Right now only CHECK constraints can be inherited */
5291 /*
5292 * Perform the actual constraint deletion
5293 */
5301 }
5311 /*
5312 * Propagate to children as appropriate. Unlike most other ALTER
5313 * routines, we have to do this one level of recursion at a time; we can't
5314 * use find_all_inheritors to do it in one pass.
5315 */
5318 else
5322 {
5324 Relation childrel;
5330 Anum_pg_constraint_conrelid,
5339 {
5340 HeapTuple copy_tuple;
5344 /* Right now only CHECK constraints can be inherited */
5361 {
5362 /*
5363 * If the child constraint has other definition sources,
5364 * just decrement its inheritance count; if not, recurse
5365 * to delete it.
5366 */
5368 {
5369 /* Time to delete this child constraint, too */
5372 }
5373 else
5374 {
5375 /* Child constraint must survive my deletion */
5380 /* Make update visible */
5382 }
5383 }
5384 else
5385 {
5386 /*
5387 * If we were told to drop ONLY in this table (no
5388 * recursion), we need to mark the inheritors' constraints
5389 * as locally defined rather than inherited.
5390 */
5397 /* Make update visible */
5399 }
5402 }
5410 constrName,
5414 }
5417 }
5419 /*
5420 * ALTER COLUMN TYPE
5421 */
5422 static void
5427 {
5430 HeapTuple tuple;
5431 Form_pg_attribute attTup;
5432 AttrNumber attnum;
5433 Oid targettype;
5434 int32 targettypmod;
5439 /* lookup the attribute so we can check inheritance status */
5449 /* Can't alter a system attribute */
5454 colName)));
5456 /* Don't alter inherited columns */
5461 colName)));
5463 /* Look up the target type */
5466 /* make sure datatype is legal for a column */
5469 /*
5470 * Set up an expression to transform the old data value to the new type.
5471 * If a USING option was given, transform and use that expression, else
5472 * just take the old value and try to coerce it. We do this first so that
5473 * type incompatibility can be detected before we waste effort, and
5474 * because we need the expression to be parsed against the original table
5475 * rowtype.
5476 */
5478 {
5481 /* Expression must be able to access vars of old table */
5483 rel,
5484 NULL,
5491 /* It can't return a set */
5497 /* No subplans or aggregates, either... */
5506 }
5507 else
5508 {
5512 }
5517 COERCION_ASSIGNMENT,
5518 COERCE_IMPLICIT_CAST,
5526 /*
5527 * Add a work queue item to make ATRewriteTable update the column
5528 * contents.
5529 */
5538 /*
5539 * The recursion case is handled by ATSimpleRecursion. However, if we are
5540 * told not to recurse, there had better not be any child tables; else the
5541 * alter would put them out of step.
5542 */
5550 colName)));
5551 }
5553 static void
5556 {
5557 HeapTuple heapTup;
5558 Form_pg_attribute attTup;
5559 AttrNumber attnum;
5560 HeapTuple typeTuple;
5561 Form_pg_type tform;
5562 Oid targettype;
5563 int32 targettypmod;
5565 Relation attrelation;
5566 Relation depRel;
5568 SysScanDesc scan;
5569 HeapTuple depTup;
5573 /* Look up the target column */
5583 /* Check for multiple ALTER TYPE on same column --- can't cope */
5589 colName)));
5591 /* Look up the target type (should not fail, since prep found it) */
5596 /*
5597 * If there is a default expression for the column, get it and ensure we
5598 * can coerce it to the new datatype. (We must do this before changing
5599 * the column type, because build_column_default itself will try to
5600 * coerce, and will not issue the error message we want if it fails.)
5601 *
5602 * We remove any implicit coercion steps at the top level of the old
5603 * default expression; this has been agreed to satisfy the principle of
5604 * least surprise. (The conversion to the new column type should act like
5605 * it started from what the user sees as the stored expression, and the
5606 * implicit coercions aren't going to be shown.)
5607 */
5609 {
5616 COERCION_ASSIGNMENT,
5617 COERCE_IMPLICIT_CAST,
5624 }
5625 else
5628 /*
5629 * Find everything that depends on the column (constraints, indexes, etc),
5630 * and record enough information to let us recreate the objects.
5631 *
5632 * The actual recreation does not happen here, but only after we have
5633 * performed all the individual ALTER TYPE operations. We have to save
5634 * the info before executing ALTER TYPE, though, else the deparser will
5635 * get confused.
5636 *
5637 * There could be multiple entries for the same object, so we must check
5638 * to ensure we process each one only once. Note: we assume that an index
5639 * that implements a constraint will not show a direct dependency on the
5640 * column.
5641 */
5645 Anum_pg_depend_refclassid,
5649 Anum_pg_depend_refobjid,
5653 Anum_pg_depend_refobjsubid,
5661 {
5663 ObjectAddress foundObject;
5665 /* We don't expect any PIN dependencies on columns */
5674 {
5676 {
5680 {
5683 {
5688 }
5689 }
5691 {
5692 /*
5693 * This must be a SERIAL column's sequence. We need
5694 * not do anything to it.
5695 */
5697 }
5698 else
5699 {
5700 /* Not expecting any other direct dependencies... */
5703 }
5705 }
5711 {
5714 /*
5715 * Put NORMAL dependencies at the front of the list and
5716 * AUTO dependencies at the back. This makes sure that
5717 * foreign-key constraints depending on this column will
5718 * be dropped before unique or primary-key constraints of
5719 * the column; which we must have because the FK
5720 * constraints depend on the indexes belonging to the
5721 * unique constraints.
5722 */
5724 {
5731 }
5732 else
5733 {
5739 defstring);
5740 }
5741 }
5745 /* XXX someday see if we can cope with revising views */
5751 colName)));
5756 /*
5757 * Ignore the column's default expression, since we will fix
5758 * it below.
5759 */
5778 /*
5779 * We don't expect any of these sorts of objects to depend on
5780 * a column.
5781 */
5789 }
5790 }
5794 /*
5795 * Now scan for dependencies of this column on other things. The only
5796 * thing we should find is the dependency on the column datatype, which we
5797 * want to remove.
5798 */
5800 Anum_pg_depend_classid,
5804 Anum_pg_depend_objid,
5808 Anum_pg_depend_objsubid,
5816 {
5827 }
5833 /*
5834 * Here we go --- change the recorded column type. (Note heapTup is a
5835 * copy of the syscache entry, so okay to scribble on.)
5836 */
5849 /* keep system catalog indexes current */
5854 /* Install dependency on new datatype */
5857 /*
5858 * Drop any pg_statistic entry for the column, since it's now wrong type
5859 */
5862 /*
5863 * Update the default, if present, by brute force --- remove and re-add
5864 * the default. Probably unsafe to take shortcuts, since the new version
5865 * may well have additional dependencies. (It's okay to do this now,
5866 * rather than after other ALTER TYPE commands, since the default won't
5867 * depend on other column types.)
5868 */
5870 {
5871 /* Must make new row visible since it will be updated again */
5874 /*
5875 * We use RESTRICT here for safety, but at present we do not expect
5876 * anything to depend on the default.
5877 */
5881 }
5883 /* Cleanup */
5885 }
5887 /*
5888 * Cleanup after we've finished all the ALTER TYPE operations for a
5889 * particular relation. We have to drop and recreate all the indexes
5890 * and constraints that depend on the altered columns.
5891 */
5892 static void
5894 {
5895 ObjectAddress obj;
5898 /*
5899 * Re-parse the index and constraint definitions, and attach them to the
5900 * appropriate work queue entries. We do this before dropping because in
5901 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
5902 * lock on the table the constraint is attached to, and we need to get
5903 * that before dropping. It's safe because the parser won't actually look
5904 * at the catalogs to detect the existing entry.
5905 */
5911 /*
5912 * Now we can drop the existing constraints and indexes --- constraints
5913 * first, since some of them might depend on the indexes. In fact, we
5914 * have to delete FOREIGN KEY constraints before UNIQUE constraints, but
5915 * we already ordered the constraint list to ensure that would happen. It
5916 * should be okay to use DROP_RESTRICT here, since nothing else should be
5917 * depending on these objects.
5918 */
5920 {
5925 }
5928 {
5933 }
5935 /*
5936 * The objects will get recreated during subsequent passes over the work
5937 * queue.
5938 */
5939 }
5941 static void
5943 {
5948 /*
5949 * We expect that we will get only ALTER TABLE and CREATE INDEX
5950 * statements. Hence, there is no need to pass them through
5951 * parse_analyze() or the rewriter, but instead we need to pass them
5952 * through parse_utilcmd.c to make them ready for execution.
5953 */
5957 {
5963 cmd));
5967 cmd));
5968 else
5970 }
5972 /*
5973 * Attach each generated command to the proper place in the work queue.
5974 * Note this could result in creation of entirely new work-queue entries.
5975 */
5977 {
5979 Relation rel;
5983 {
5985 {
5998 }
6000 {
6007 {
6011 {
6024 }
6025 }
6028 }
6032 }
6033 }
6034 }
6037 /*
6038 * ALTER TABLE OWNER
6039 *
6040 * recursing is true if we are recursing from a table to its indexes,
6041 * sequences, or toast table. We don't allow the ownership of those things to
6042 * be changed separately from the parent table. Also, we can skip permission
6043 * checks (this is necessary not just an optimization, else we'd fail to
6044 * handle toast tables properly).
6045 *
6046 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
6047 * free-standing composite type.
6048 */
6049 void
6051 {
6052 Relation target_rel;
6053 Relation class_rel;
6054 HeapTuple tuple;
6055 Form_pg_class tuple_class;
6057 /*
6058 * Get exclusive lock till end of transaction on the target table. Use
6059 * relation_open so that we can work on indexes and sequences.
6060 */
6063 /* Get its pg_class tuple, too */
6073 /* Can we change the ownership of this tuple? */
6075 {
6078 /* ok to change owner */
6082 {
6083 /*
6084 * Because ALTER INDEX OWNER used to be allowed, and in fact
6085 * is generated by old versions of pg_dump, we give a warning
6086 * and do nothing rather than erroring out. Also, to avoid
6087 * unnecessary chatter while restoring those old dumps, say
6088 * nothing at all if the command would be a no-op anyway.
6089 */
6096 /* quick hack to exit via the no-op path */
6098 }
6103 {
6104 /* if it's an owned sequence, disallow changing it by itself */
6105 Oid tableId;
6106 int32 colId;
6116 }
6130 /* FALL THRU */
6136 }
6138 /*
6139 * If the new owner is the same as the existing owner, consider the
6140 * command to have succeeded. This is for dump restoration purposes.
6141 */
6143 {
6148 Datum aclDatum;
6150 HeapTuple newtuple;
6152 /* skip permission checks when recursing to index or toast table */
6154 {
6155 /* Superusers can always do it */
6157 {
6159 AclResult aclresult;
6161 /* Otherwise, must be owner of the existing object */
6166 /* Must be able to become new owner */
6169 /* New owner must have CREATE privilege on namespace */
6171 ACL_CREATE);
6175 }
6176 }
6184 /*
6185 * Determine the modified ACL for the new owner. This is only
6186 * necessary when the ACL is non-null.
6187 */
6189 Anum_pg_class_relacl,
6192 {
6197 }
6199 newtuple = heap_modifytuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
6206 /*
6207 * Update owner dependency reference, if any. A composite type has
6208 * none, because it's tracked for the pg_type entry instead of here;
6209 * indexes and TOAST tables don't have their own entries either.
6210 */
6215 newOwnerId);
6217 /*
6218 * Also change the ownership of the table's rowtype, if it has one
6219 */
6224 /*
6225 * If we are operating on a table, also change the ownership of any
6226 * indexes and sequences that belong to the table, as well as the
6227 * table's toast table (if it has one)
6228 */
6231 {
6235 /* Find all the indexes belonging to this relation */
6238 /* For each index, recursively change its ownership */
6243 }
6246 {
6247 /* If it has a toast table, recurse to change its ownership */
6252 /* If it has dependent sequences, recurse to change them too */
6254 }
6255 }
6260 }
6262 /*
6263 * change_owner_recurse_to_sequences
6264 *
6265 * Helper function for ATExecChangeOwner. Examines pg_depend searching
6266 * for sequences that are dependent on serial columns, and changes their
6267 * ownership.
6268 */
6269 static void
6271 {
6272 Relation depRel;
6273 SysScanDesc scan;
6275 HeapTuple tup;
6277 /*
6278 * SERIAL sequences are those having an auto dependency on one of the
6279 * table's columns (we don't care *which* column, exactly).
6280 */
6284 Anum_pg_depend_refclassid,
6288 Anum_pg_depend_refobjid,
6291 /* we leave refobjsubid unspecified */
6297 {
6299 Relation seqRel;
6301 /* skip dependencies other than auto dependencies on columns */
6308 /* Use relation_open just in case it's an index */
6311 /* skip non-sequence relations */
6313 {
6314 /* No need to keep the lock */
6317 }
6319 /* We don't need to close the sequence while we alter it. */
6322 /* Now we can close it. Keep the lock till end of transaction. */
6324 }
6329 }
6331 /*
6332 * ALTER TABLE CLUSTER ON
6333 *
6334 * The only thing we have to do is to change the indisclustered bits.
6335 */
6336 static void
6338 {
6339 Oid indexOid;
6349 /* Check index is valid to cluster on */
6352 /* And do the work */
6354 }
6356 /*
6357 * ALTER TABLE SET WITHOUT CLUSTER
6358 *
6359 * We have to find any indexes on the table that have indisclustered bit
6360 * set and turn it off.
6361 */
6362 static void
6364 {
6366 }
6368 /*
6369 * ALTER TABLE SET TABLESPACE
6370 */
6371 static void
6373 {
6374 Oid tablespaceId;
6375 AclResult aclresult;
6377 /* Check that the tablespace exists */
6384 /* Check its permissions */
6389 /* Save info for Phase 3 to do the real work */
6395 }
6397 /*
6398 * ALTER TABLE/INDEX SET (...) or RESET (...)
6399 */
6400 static void
6402 {
6403 Oid relid;
6404 Relation pgclass;
6405 HeapTuple tuple;
6406 HeapTuple newtuple;
6407 Datum datum;
6409 Datum newOptions;
6419 /* Get the old reloptions */
6429 /* Generate new proposed reloptions (text array) */
6433 /* Validate */
6435 {
6449 }
6451 /*
6452 * All we need do here is update the pg_class row; the new options will be
6453 * propagated into relcaches during post-commit cache inval.
6454 */
6461 else
6478 }
6480 /*
6481 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
6482 * rewriting to be done, so we just want to copy the data as fast as possible.
6483 */
6484 static void
6486 {
6487 Relation rel;
6488 Oid oldTableSpace;
6489 Oid reltoastrelid;
6490 Oid reltoastidxid;
6491 Oid newrelfilenode;
6492 RelFileNode newrnode;
6493 SMgrRelation dstrel;
6494 Relation pg_class;
6495 HeapTuple tuple;
6496 Form_pg_class rd_rel;
6497 ForkNumber forkNum;
6499 /*
6500 * Need lock here in case we are recursing to toast table or index
6501 */
6504 /*
6505 * We can never allow moving of shared or nailed-in-cache relations,
6506 * because we can't support changing their reltablespace values.
6507 */
6514 /* Can't move a non-shared relation into pg_global */
6520 /*
6521 * Don't allow moving temp tables of other backends ... their local buffer
6522 * manager is not going to cope.
6523 */
6529 /*
6530 * No work if no change in tablespace.
6531 */
6535 {
6538 }
6543 /* Get a modifiable copy of the relation's pg_class row */
6553 /*
6554 * Since we copy the file directly without looking at the shared buffers,
6555 * we'd better first flush out any pages of the source relation that are
6556 * in shared buffers. We assume no new changes will be made while we are
6557 * holding exclusive lock on the rel.
6558 */
6561 /*
6562 * Relfilenodes are not unique across tablespaces, so we need to allocate
6563 * a new one in the new tablespace.
6564 */
6567 NULL);
6569 /* Open old and new relation */
6577 /*
6578 * Create and copy all forks of the relation, and schedule unlinking
6579 * of old physical files.
6580 *
6581 * NOTE: any conflict in relfilenode value will be caught in
6582 * smgrcreate() below.
6583 */
6585 {
6587 {
6592 }
6593 }
6595 /* Close old and new relation */
6599 /* update the pg_class row */
6611 /* Make sure the reltablespace change is visible */
6614 /* Move associated toast relation and/or index, too */
6619 }
6621 /*
6622 * Copy data, block by block
6623 */
6624 static void
6627 {
6629 BlockNumber nblocks;
6630 BlockNumber blkno;
6634 /*
6635 * We need to log the copied data in WAL iff WAL archiving is enabled AND
6636 * it's not a temp rel.
6637 */
6643 {
6646 /* XLOG stuff */
6650 /*
6651 * Now write the page. We say isTemp = true even if it's not a temp
6652 * rel, because there's no need for smgr to schedule an fsync for this
6653 * write; we'll do it ourselves below.
6654 */
6656 }
6658 /*
6659 * If the rel isn't temp, we must fsync it down to disk before it's safe
6660 * to commit the transaction. (For a temp rel we don't care since the rel
6661 * will be uninteresting after a crash anyway.)
6662 *
6663 * It's obvious that we must do this when not WAL-logging the copy. It's
6664 * less obvious that we have to do it even if we did WAL-log the copied
6665 * pages. The reason is that since we're copying outside shared buffers, a
6666 * CHECKPOINT occurring during the copy has no way to flush the previously
6667 * written data to disk (indeed it won't know the new rel even exists). A
6668 * crash later on would replay WAL from the checkpoint, therefore it
6669 * wouldn't replay our earlier WAL entries. If we do not fsync those pages
6670 * here, they might still not be on disk when the crash occurs.
6671 */
6674 }
6676 /*
6677 * ALTER TABLE ENABLE/DISABLE TRIGGER
6678 *
6679 * We just pass this off to trigger.c.
6680 */
6681 static void
6684 {
6686 }
6688 /*
6689 * ALTER TABLE ENABLE/DISABLE RULE
6690 *
6691 * We just pass this off to rewriteDefine.c.
6692 */
6693 static void
6696 {
6698 }
6700 /*
6701 * ALTER TABLE INHERIT
6702 *
6703 * Add a parent to the child's parents. This verifies that all the columns and
6704 * check constraints of the parent appear in the child and that they have the
6705 * same data types and expressions.
6706 */
6707 static void
6709 {
6710 Relation parent_rel,
6711 catalogRelation;
6712 SysScanDesc scan;
6713 ScanKeyData key;
6714 HeapTuple inheritsTuple;
6715 int32 inhseqno;
6718 /*
6719 * AccessShareLock on the parent is what's obtained during normal CREATE
6720 * TABLE ... INHERITS ..., so should be enough here.
6721 */
6724 /*
6725 * Must be owner of both parent and child -- child was checked by
6726 * ATSimplePermissions call in ATPrepCmd
6727 */
6730 /* Permanent rels cannot inherit from temporary ones */
6738 /*
6739 * Check for duplicates in the list of parents, and determine the highest
6740 * inhseqno already present; we'll use the next one for the new parent.
6741 * (Note: get RowExclusiveLock because we will write pg_inherits below.)
6742 *
6743 * Note: we do not reject the case where the child already inherits from
6744 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
6745 */
6748 Anum_pg_inherits_inhrelid,
6754 /* inhseqno sequences start at 1 */
6757 {
6767 }
6770 /*
6771 * Prevent circularity by seeing if proposed parent inherits from child.
6772 * (In particular, this disallows making a rel inherit from itself.)
6773 *
6774 * This is not completely bulletproof because of race conditions: in
6775 * multi-level inheritance trees, someone else could concurrently be
6776 * making another inheritance link that closes the loop but does not join
6777 * either of the rels we have locked. Preventing that seems to require
6778 * exclusive locks on the entire inheritance tree, which is a cure worse
6779 * than the disease. find_all_inheritors() will cope with circularity
6780 * anyway, so don't sweat it too much.
6781 */
6792 /* If parent has OIDs then child must have OIDs */
6800 /* Match up the columns and bump attinhcount as needed */
6803 /* Match up the constraints and bump coninhcount as needed */
6806 /*
6807 * OK, it looks valid. Make the catalog entries that show inheritance.
6808 */
6812 catalogRelation);
6814 /* Now we're done with pg_inherits */
6817 /* keep our lock on the parent relation until commit */
6819 }
6821 /*
6822 * Obtain the source-text form of the constraint expression for a check
6823 * constraint, given its pg_constraint tuple
6824 */
6827 {
6828 Form_pg_constraint con;
6830 Datum attr;
6831 Datum expr;
6841 }
6843 /*
6844 * Determine whether two check constraints are functionally equivalent
6845 *
6846 * The test we apply is to see whether they reverse-compile to the same
6847 * source string. This insulates us from issues like whether attributes
6848 * have the same physical column numbers in parent and child relations.
6849 */
6850 static bool
6852 {
6861 else
6863 }
6865 /*
6866 * Check columns in child table match up with columns in parent, and increment
6867 * their attinhcount.
6868 *
6869 * Called by ATExecAddInherit
6870 *
6871 * Currently all parent columns must be found in child. Missing columns are an
6872 * error. One day we might consider creating new columns like CREATE TABLE
6873 * does. However, that is widely unpopular --- in the common use case of
6874 * partitioned tables it's a foot-gun.
6875 *
6876 * The data type must match exactly. If the parent column is NOT NULL then
6877 * the child must be as well. Defaults are not compared, however.
6878 */
6879 static void
6881 {
6882 Relation attrrel;
6883 AttrNumber parent_attno;
6885 TupleDesc tupleDesc;
6887 HeapTuple tuple;
6896 {
6900 /* Ignore dropped columns in the parent. */
6904 /* Find same column in child (matching on column name). */
6906 attributeName);
6908 {
6909 /* Check they are same type and typmod */
6918 attributeName)));
6924 attributeName)));
6926 /*
6927 * OK, bump the child column's inheritance count. (If we fail
6928 * later on, this change will just roll back.)
6929 */
6934 }
6935 else
6936 {
6940 attributeName)));
6941 }
6942 }
6945 }
6947 /*
6948 * Check constraints in child table match up with constraints in parent,
6949 * and increment their coninhcount.
6950 *
6951 * Called by ATExecAddInherit
6952 *
6953 * Currently all constraints in parent must be present in the child. One day we
6954 * may consider adding new constraints like CREATE TABLE does. We may also want
6955 * to allow an optional flag on parent table constraints indicating they are
6956 * intended to ONLY apply to the master table, not to the children. That would
6957 * make it possible to ensure no records are mistakenly inserted into the
6958 * master in partitioned tables rather than the appropriate child.
6959 *
6960 * XXX This is O(N^2) which may be an issue with tables with hundreds of
6961 * constraints. As long as tables have more like 10 constraints it shouldn't be
6962 * a problem though. Even 100 constraints ought not be the end of the world.
6963 */
6964 static void
6966 {
6967 Relation catalog_relation;
6968 TupleDesc tuple_desc;
6969 SysScanDesc parent_scan;
6970 ScanKeyData parent_key;
6971 HeapTuple parent_tuple;
6976 /* Outer loop scans through the parent's constraint definitions */
6978 Anum_pg_constraint_conrelid,
6985 {
6987 SysScanDesc child_scan;
6988 ScanKeyData child_key;
6989 HeapTuple child_tuple;
6995 /* Search for a child constraint matching this one */
6997 Anum_pg_constraint_conrelid,
7004 {
7006 HeapTuple child_copy;
7022 /*
7023 * OK, bump the child constraint's inheritance count. (If we fail
7024 * later on, this change will just roll back.)
7025 */
7035 }
7044 }
7048 }
7050 /*
7051 * ALTER TABLE NO INHERIT
7052 *
7053 * Drop a parent from the child's parents. This just adjusts the attinhcount
7054 * and attislocal of the columns and removes the pg_inherit and pg_depend
7055 * entries.
7056 *
7057 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
7058 * up attislocal stays true, which means if a child is ever removed from a
7059 * parent then its columns will never be automatically dropped which may
7060 * surprise. But at least we'll never surprise by dropping columns someone
7061 * isn't expecting to be dropped which would actually mean data loss.
7062 *
7063 * coninhcount and conislocal for inherited constraints are adjusted in
7064 * exactly the same way.
7065 */
7066 static void
7068 {
7069 Relation parent_rel;
7070 Relation catalogRelation;
7071 SysScanDesc scan;
7073 HeapTuple inheritsTuple,
7074 attributeTuple,
7075 constraintTuple,
7076 depTuple;
7080 /*
7081 * AccessShareLock on the parent is probably enough, seeing that DROP
7082 * TABLE doesn't lock parent tables at all. We need some lock since we'll
7083 * be inspecting the parent's schema.
7084 */
7087 /*
7088 * We don't bother to check ownership of the parent table --- ownership of
7089 * the child is presumed enough rights.
7090 */
7092 /*
7093 * Find and destroy the pg_inherits entry linking the two, or error out if
7094 * there is none.
7095 */
7098 Anum_pg_inherits_inhrelid,
7105 {
7106 Oid inhparent;
7110 {
7114 }
7115 }
7127 /*
7128 * Search through child columns looking for ones matching parent rel
7129 */
7132 Anum_pg_attribute_attrelid,
7138 {
7141 /* Ignore if dropped or not inherited */
7149 {
7150 /* Decrement inhcount and possibly set islocal to true */
7161 }
7162 }
7166 /*
7167 * Likewise, find inherited check constraints and disinherit them.
7168 * To do this, we first need a list of the names of the parent's check
7169 * constraints. (We cheat a bit by only checking for name matches,
7170 * assuming that the expressions will match.)
7171 */
7174 Anum_pg_constraint_conrelid,
7183 {
7188 }
7192 /* Now scan the child's constraints */
7194 Anum_pg_constraint_conrelid,
7201 {
7211 {
7213 {
7216 }
7217 }
7220 {
7221 /* Decrement inhcount and possibly set islocal to true */
7235 }
7236 }
7241 /*
7242 * Drop the dependency
7243 *
7244 * There's no convenient way to do this, so go trawling through pg_depend
7245 */
7249 Anum_pg_depend_classid,
7253 Anum_pg_depend_objid,
7257 Anum_pg_depend_objsubid,
7265 {
7273 }
7278 /* keep our lock on the parent relation until commit */
7280 }
7283 /*
7284 * Execute ALTER TABLE SET SCHEMA
7285 *
7286 * Note: caller must have checked ownership of the relation already
7287 */
7288 void
7290 ObjectType stmttype)
7291 {
7292 Relation rel;
7293 Oid relid;
7294 Oid oldNspOid;
7295 Oid nspOid;
7296 Relation classRel;
7303 /* Check relation type against type specified in the ALTER command */
7305 {
7307 /*
7308 * For mostly-historical reasons, we allow ALTER TABLE to apply
7309 * to all relation types.
7310 */
7331 }
7333 /* Can we change the schema of this tuple? */
7335 {
7338 /* ok to change schema */
7341 {
7342 /* if it's an owned sequence, disallow moving it by itself */
7343 Oid tableId;
7344 int32 colId;
7353 }
7364 /* FALL THRU */
7370 }
7372 /* get schema OID and check its permissions */
7380 newschema)));
7382 /* disallow renaming into or out of temp schemas */
7388 /* same for TOAST schema */
7394 /* OK, modify the pg_class row and pg_depend entry */
7399 /* Fix the table's rowtype too */
7402 /* Fix other dependent stuff */
7404 {
7408 }
7412 /* close rel, but keep lock until commit */
7414 }
7416 /*
7417 * The guts of relocating a relation to another namespace: fix the pg_class
7418 * entry, and the pg_depend entry if any. Caller must already have
7419 * opened and write-locked pg_class.
7420 */
7421 void
7425 {
7426 HeapTuple classTup;
7427 Form_pg_class classForm;
7438 /* check for duplicate name (more friendly than unique-index failure) */
7447 /* classTup is a copy, so OK to scribble on */
7453 /* Update dependency on schema if caller said so */
7461 }
7463 /*
7464 * Move all indexes for the specified relation to another namespace.
7465 *
7466 * Note: we assume adequate permission checking was done by the caller,
7467 * and that the caller has a suitable lock on the owning relation.
7468 */
7469 static void
7472 {
7479 {
7482 /*
7483 * Note: currently, the index will not have its own dependency on the
7484 * namespace, so we don't need to do changeDependencyFor(). There's no
7485 * rowtype in pg_type, either.
7486 */
7490 }
7493 }
7495 /*
7496 * Move all SERIAL-column sequences of the specified relation to another
7497 * namespace.
7498 *
7499 * Note: we assume adequate permission checking was done by the caller,
7500 * and that the caller has a suitable lock on the owning relation.
7501 */
7502 static void
7505 {
7506 Relation depRel;
7507 SysScanDesc scan;
7509 HeapTuple tup;
7511 /*
7512 * SERIAL sequences are those having an auto dependency on one of the
7513 * table's columns (we don't care *which* column, exactly).
7514 */
7518 Anum_pg_depend_refclassid,
7522 Anum_pg_depend_refobjid,
7525 /* we leave refobjsubid unspecified */
7531 {
7533 Relation seqRel;
7535 /* skip dependencies other than auto dependencies on columns */
7542 /* Use relation_open just in case it's an index */
7545 /* skip non-sequence relations */
7547 {
7548 /* No need to keep the lock */
7551 }
7553 /* Fix the pg_class and pg_depend entries */
7558 /*
7559 * Sequences have entries in pg_type. We need to be careful to move
7560 * them to the new namespace, too.
7561 */
7565 /* Now we can close it. Keep the lock till end of transaction. */
7567 }
7572 }
7575 /*
7576 * This code supports
7577 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
7578 *
7579 * Because we only support this for TEMP tables, it's sufficient to remember
7580 * the state in a backend-local data structure.
7581 */
7583 /*
7584 * Register a newly-created relation's ON COMMIT action.
7585 */
7586 void
7588 {
7590 MemoryContext oldcxt;
7592 /*
7593 * We needn't bother registering the relation unless there is an ON COMMIT
7594 * action we need to take.
7595 */
7610 }
7612 /*
7613 * Unregister any ON COMMIT action when a relation is deleted.
7614 *
7615 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
7616 */
7617 void
7619 {
7623 {
7627 {
7630 }
7631 }
7632 }
7634 /*
7635 * Perform ON COMMIT actions.
7636 *
7637 * This is invoked just before actually committing, since it's possible
7638 * to encounter errors.
7639 */
7640 void
7642 {
7647 {
7650 /* Ignore entry if already dropped in this xact */
7655 {
7658 /* Do nothing (there shouldn't be such entries, actually) */
7664 {
7665 ObjectAddress object;
7672 /*
7673 * Note that table deletion will call
7674 * remove_on_commit_action, so the entry should get marked
7675 * as deleted.
7676 */
7679 }
7680 }
7681 }
7683 {
7686 }
7687 }
7689 /*
7690 * Post-commit or post-abort cleanup for ON COMMIT management.
7691 *
7692 * All we do here is remove no-longer-needed OnCommitItem entries.
7693 *
7694 * During commit, remove entries that were deleted during this transaction;
7695 * during abort, remove those created during this transaction.
7696 */
7697 void
7699 {
7707 {
7712 {
7713 /* cur_item must be removed */
7718 else
7720 }
7721 else
7722 {
7723 /* cur_item must be preserved */
7728 }
7729 }
7730 }
7732 /*
7733 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
7734 *
7735 * During subabort, we can immediately remove entries created during this
7736 * subtransaction. During subcommit, just relabel entries marked during
7737 * this subtransaction as being the parent's responsibility.
7738 */
7739 void
7741 SubTransactionId parentSubid)
7742 {
7750 {
7754 {
7755 /* cur_item must be removed */
7760 else
7762 }
7763 else
7764 {
7765 /* cur_item must be preserved */
7772 }
7773 }
7774 }