| blob | 721d24783b4e38b472fee53dbce5bcd5ef9518be |
1 /*-------------------------------------------------------------------------
2 *
3 * tablecmds.c
4 * Commands for creating and altering table structures and settings
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/commands/tablecmds.c
12 *
13 *-------------------------------------------------------------------------
14 */
110 /*
111 * ON COMMIT action list
112 */
114 {
118 /*
119 * If this entry was created during the current transaction,
120 * creating_subid is the ID of the creating subxact; if created in a prior
121 * transaction, creating_subid is zero. If deleted during the current
122 * transaction, deleting_subid is the ID of the deleting subxact; if no
123 * deletion request is pending, deleting_subid is zero.
124 */
125 SubTransactionId creating_subid;
126 SubTransactionId deleting_subid;
132 /*
133 * State information for ALTER TABLE
134 *
135 * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
136 * structs, one for each table modified by the operation (the named table
137 * plus any child tables that are affected). We save lists of subcommands
138 * to apply to this table (possibly modified by parse transformation steps);
139 * these lists will be executed in Phase 2. If a Phase 3 step is needed,
140 * necessary information is stored in the constraints and newvals lists.
141 *
142 * Phase 2 is divided into multiple passes; subcommands are executed in
143 * a pass determined by subcommand type.
144 */
147 {
155 /* We could support a RENAME COLUMN pass here, but not currently used */
164 #define AT_NUM_PASSES (AT_PASS_MISC + 1)
167 {
168 /* Information saved before any work commences: */
173 /*
174 * Transiently set during Phase 2, normally set to NULL.
175 *
176 * ATRewriteCatalogs sets this when it starts, and closes when ATExecCmd
177 * returns control. This can be exploited by ATExecCmd subroutines to
178 * close/reopen across transaction boundaries.
179 */
180 Relation rel;
182 /* Information saved by Phase 1 for Phase 2: */
184 /* Information saved by Phases 1/2 for Phase 3: */
192 * if above is true */
197 /* true, if validating default due to some other attach/detach */
199 /* Objects to rebuild after completing ALTER TYPE operations */
210 /* Struct describing one new constraint to check in Phase 3 scan */
211 /* Note: new not-null constraints are handled elsewhere */
213 {
223 /*
224 * Struct describing one new column value that needs to be computed during
225 * Phase 3 copy (this could be either a new column with a non-null default, or
226 * a column that we're changing the type of). Columns without such an entry
227 * are just copied from the old table during ATRewriteTable. Note that the
228 * expr is an expression over *old* table values, except when is_generated
229 * is true; then it is an expression over columns of the *new* tuple.
230 */
232 {
239 /*
240 * Error-reporting support for RemoveRelations
241 */
242 struct dropmsgstrings
243 {
250 };
254 ERRCODE_UNDEFINED_TABLE,
260 ERRCODE_UNDEFINED_TABLE,
266 ERRCODE_UNDEFINED_TABLE,
272 ERRCODE_UNDEFINED_TABLE,
278 ERRCODE_UNDEFINED_OBJECT,
284 ERRCODE_UNDEFINED_OBJECT,
290 ERRCODE_UNDEFINED_OBJECT,
296 ERRCODE_UNDEFINED_TABLE,
302 ERRCODE_UNDEFINED_OBJECT,
308 };
310 /* communication between RemoveRelations and RangeVarCallbackForDropRelation */
311 struct DropRelationCallbackState
312 {
313 /* These fields are set by RemoveRelations: */
315 LOCKMODE heap_lockmode;
316 /* These fields are state to track which subsidiary locks are held: */
317 Oid heapOid;
318 Oid partParentOid;
319 /* These fields are passed back by RangeVarCallbackForDropRelation: */
322 };
324 /* Alter table target-type flags for ATSimplePermissions */
325 #define ATT_TABLE 0x0001
326 #define ATT_VIEW 0x0002
327 #define ATT_MATVIEW 0x0004
328 #define ATT_INDEX 0x0008
329 #define ATT_COMPOSITE_TYPE 0x0010
330 #define ATT_FOREIGN_TABLE 0x0020
331 #define ATT_PARTITIONED_INDEX 0x0040
332 #define ATT_SEQUENCE 0x0080
334 /*
335 * ForeignTruncateInfo
336 *
337 * Information related to truncation of foreign tables. This is used for
338 * the elements in a hash table. It uses the server OID as lookup key,
339 * and includes a per-server list of all foreign tables involved in the
340 * truncation.
341 */
343 {
344 Oid serverid;
348 /*
349 * Partition tables are expected to be dropped when the parent partitioned
350 * table gets dropped. Hence for partitioning we use AUTO dependency.
351 * Otherwise, for regular inheritance use NORMAL dependency.
352 */
353 #define child_dependency_type(child_is_partition) \
354 ((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)
364 static void MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef);
365 static ColumnDef *MergeInheritedAttribute(List *inh_columns, int exist_attno, const ColumnDef *newdef);
366 static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel, bool ispartition);
378 LOCKMODE lockmode);
383 LOCKMODE lockmode);
417 AlterTablePass cur_pass,
430 LOCKMODE lockmode,
433 DropBehavior behavior);
450 LOCKMODE lockmode,
467 static ObjectAddress ATExecDropIdentity(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode,
469 static ObjectAddress ATExecSetExpression(AlteredTableInfo *tab, Relation rel, const char *colName,
471 static void ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode);
472 static ObjectAddress ATExecDropExpression(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
483 DropBehavior behavior,
494 LOCKMODE lockmode);
502 LOCKMODE lockmode);
506 LOCKMODE lockmode);
525 Relation partitionRel);
528 Relation partRel);
531 Oid indexOid,
536 Oid indexOid,
540 Oid partRelid,
544 Oid parentInsTrigger,
545 Oid parentUpdTrigger,
546 Relation trigrel);
556 DropBehavior behavior,
573 LOCKMODE lockmode);
589 LOCKMODE lockmode);
599 AlterTableType operation,
600 LOCKMODE lockmode);
603 LOCKMODE lockmode);
610 DependencyType deptype);
628 static void ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
630 PartitionStrategy strategy);
654 Relation partitionTbl);
666 /* ----------------------------------------------------------------
667 * DefineRelation
668 * Creates a new relation.
669 *
670 * stmt carries parsetree information from an ordinary CREATE TABLE statement.
671 * The other arguments are used to extend the behavior for other cases:
672 * relkind: relkind to assign to the new relation
673 * ownerId: if not InvalidOid, use this as the new relation's owner.
674 * typaddress: if not null, it's set to the pg_type entry's address.
675 * queryString: for error reporting
676 *
677 * Note that permissions checks are done against current user regardless of
678 * ownerId. A nonzero ownerId is used when someone is creating a relation
679 * "on behalf of" someone else, so we still want to see that the current user
680 * has permissions to do it.
681 *
682 * If successful, returns the address of the new relation.
683 * ----------------------------------------------------------------
684 */
685 ObjectAddress
688 {
690 Oid namespaceId;
691 Oid relationId;
692 Oid tablespaceId;
693 Relation rel;
694 TupleDesc descriptor;
699 Datum reloptions;
701 AttrNumber attnum;
704 Oid ofTypeId;
705 ObjectAddress address;
706 LOCKMODE parentLockmode;
709 /*
710 * Truncate relname to appropriate length (probably a waste of time, as
711 * parser should have done this already).
712 */
715 /*
716 * Check consistency of arguments
717 */
725 {
731 }
732 else
735 /*
736 * Look up the namespace in which we are supposed to create the relation,
737 * check we have permission to create there, lock it against concurrent
738 * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
739 * namespace is selected.
740 */
741 namespaceId =
744 /*
745 * Security check: disallow creating temp tables from security-restricted
746 * code. This is needed because calling code might not expect untrusted
747 * tables to appear in pg_temp at the front of its search path.
748 */
755 /*
756 * Determine the lockmode to use when scanning parents. A self-exclusive
757 * lock is needed here.
758 *
759 * For regular inheritance, if two backends attempt to add children to the
760 * same parent simultaneously, and that parent has no pre-existing
761 * children, then both will attempt to update the parent's relhassubclass
762 * field, leading to a "tuple concurrently updated" error. Also, this
763 * interlocks against a concurrent ANALYZE on the parent table, which
764 * might otherwise be attempting to clear the parent's relhassubclass
765 * field, if its previous children were recently dropped.
766 *
767 * If the child table is a partition, then we instead grab an exclusive
768 * lock on the parent because its partition descriptor will be changed by
769 * addition of the new partition.
770 */
772 ShareUpdateExclusiveLock);
774 /* Determine the list of OIDs of the parents. */
777 {
779 Oid parentOid;
783 /*
784 * Reject duplications in the list of parents.
785 */
793 }
795 /*
796 * Select tablespace to use: an explicitly indicated one, or (in the case
797 * of a partitioned table) the parent's, if it has one.
798 */
800 {
807 }
809 {
812 }
813 else
816 /* still nothing? use the default */
819 partitioned);
821 /* Check permissions except when using database's default */
823 {
824 AclResult aclresult;
827 ACL_CREATE);
831 }
833 /* In all cases disallow placing user relations in pg_global */
839 /* Identify user ID that will own the table */
843 /*
844 * Parse and validate reloptions, if any.
845 */
850 {
859 }
862 {
863 AclResult aclresult;
870 }
871 else
874 /*
875 * Look up inheritance ancestors and generate relation schema, including
876 * inherited attributes. (Note that stmt->tableElts is destructively
877 * modified by MergeAttributes.)
878 */
885 /*
886 * Create a tuple descriptor from the relation schema. Note that this
887 * deals with column names, types, and not-null constraints, but not
888 * default values or CHECK constraints; we handle those below.
889 */
892 /*
893 * Find columns with default values and prepare for insertion of the
894 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
895 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
896 * while raw defaults go into a list of RawColumnDefault structs that will
897 * be processed by AddRelationNewConstraints. (We can't deal with raw
898 * expressions until we can do transformExpr.)
899 *
900 * We can set the atthasdef flags now in the tuple descriptor; this just
901 * saves StoreAttrDefault from having to do an immediate update of the
902 * pg_attribute rows.
903 */
909 {
911 Form_pg_attribute attr;
913 attnum++;
917 {
929 }
931 {
946 }
947 }
949 /*
950 * For relations with table AM and partitioned tables, select access
951 * method to use: an explicitly indicated one, or (in the case of a
952 * partitioned table) the parent's, if it has one.
953 */
955 {
958 }
960 {
962 {
965 }
969 }
971 /*
972 * Create the relation. Inherited defaults and constraints are passed in
973 * for immediate handling --- since they don't need parsing, they can be
974 * stored immediately.
975 */
977 namespaceId,
978 tablespaceId,
979 InvalidOid,
980 InvalidOid,
981 ofTypeId,
982 ownerId,
983 accessMethodId,
984 descriptor,
986 old_constraints),
987 relkind,
992 reloptions,
994 allowSystemTableMods,
996 InvalidOid,
997 typaddress);
999 /*
1000 * We must bump the command counter to make the newly-created relation
1001 * tuple visible for opening.
1002 */
1005 /*
1006 * Open the new relation and acquire exclusive lock on it. This isn't
1007 * really necessary for locking out other backends (since they can't see
1008 * the new rel anyway until we commit), but it keeps the lock manager from
1009 * complaining about deadlock risks.
1010 */
1013 /*
1014 * Now add any newly specified column default and generation expressions
1015 * to the new relation. These are passed to us in the form of raw
1016 * parsetrees; we need to transform them to executable expression trees
1017 * before they can be added. The most convenient way to do that is to
1018 * apply the parser's transformExpr routine, but transformExpr doesn't
1019 * work unless we have a pre-existing relation. So, the transformation has
1020 * to be postponed to this final step of CREATE TABLE.
1021 *
1022 * This needs to be before processing the partitioning clauses because
1023 * those could refer to generated columns.
1024 */
1029 /*
1030 * Make column generation expressions visible for use by partitioning.
1031 */
1034 /* Process and store partition bound, if any. */
1036 {
1040 defaultPartOid;
1041 Relation parent,
1045 /* Already have strong enough lock on the parent */
1048 /*
1049 * We are going to try to validate the partition bound specification
1050 * against the partition key of parentRel, so it better have one.
1051 */
1058 /*
1059 * The partition constraint of the default partition depends on the
1060 * partition bounds of every other partition. It is possible that
1061 * another backend might be about to execute a query on the default
1062 * partition table, and that the query relies on previously cached
1063 * default partition constraints. We must therefore take a table lock
1064 * strong enough to prevent all queries on the default partition from
1065 * proceeding until we commit and send out a shared-cache-inval notice
1066 * that will make them update their index lists.
1067 *
1068 * Order of locking: The relation being added won't be visible to
1069 * other backends until it is committed, hence here in
1070 * DefineRelation() the order of locking the default partition and the
1071 * relation being added does not matter. But at all other places we
1072 * need to lock the default relation before we lock the relation being
1073 * added or removed i.e. we should take the lock in same order at all
1074 * the places such that lock parent, lock default partition and then
1075 * lock the partition so as to avoid a deadlock.
1076 */
1077 defaultPartOid =
1083 /* Transform the bound values */
1087 /*
1088 * Add an nsitem containing this relation, so that transformExpr
1089 * called on partition bound expressions is able to report errors
1090 * using a proper context.
1091 */
1098 /*
1099 * Check first that the new partition's bound is valid and does not
1100 * overlap with any of existing partitions of the parent.
1101 */
1104 /*
1105 * If the default partition exists, its partition constraints will
1106 * change after the addition of this new partition such that it won't
1107 * allow any row that qualifies for this new partition. So, check that
1108 * the existing data in the default partition satisfies the constraint
1109 * as it will exist after adding this partition.
1110 */
1112 {
1114 /* Keep the lock until commit. */
1116 }
1118 /* Update the pg_class entry. */
1122 }
1124 /* Store inheritance information for new rel. */
1127 /*
1128 * Process the partitioning specification (if any) and store the partition
1129 * key information into the catalog.
1130 */
1132 {
1145 /* Protect fixed-size arrays here and in executor */
1150 PARTITION_MAX_KEYS)));
1152 /*
1153 * We need to transform the raw parsetrees corresponding to partition
1154 * expressions into executable expression trees. Like column defaults
1155 * and CHECK constraints, we could not have done the transformation
1156 * earlier.
1157 */
1165 partexprs,
1168 /* make it all visible */
1170 }
1172 /*
1173 * If we're creating a partition, create now all the indexes, triggers,
1174 * FKs defined in the parent.
1175 *
1176 * We can't do it earlier, because DefineIndex wants to know the partition
1177 * key which we just stored.
1178 */
1180 {
1182 Relation parent;
1186 /* Already have strong enough lock on the parent */
1190 /*
1191 * For each index in the parent table, create one in the partition
1192 */
1194 {
1198 Oid constraintOid;
1201 {
1209 else
1210 {
1213 }
1214 }
1219 idxstmt =
1223 idxstmt,
1224 InvalidOid,
1226 constraintOid,
1231 }
1235 /*
1236 * If there are any row-level triggers, clone them to the new
1237 * partition.
1238 */
1242 /*
1243 * And foreign keys too. Note that because we're freshly creating the
1244 * table, there is no need to verify these new constraints.
1245 */
1249 }
1251 /*
1252 * Now add any newly specified CHECK constraints to the new relation. Same
1253 * as for defaults above, but these need to come after partitioning is set
1254 * up.
1255 */
1262 /*
1263 * Clean up. We keep lock on new relation (although it shouldn't be
1264 * visible to anyone else anyway, until commit).
1265 */
1269 }
1271 /*
1272 * BuildDescForRelation
1273 *
1274 * Given a list of ColumnDef nodes, build a TupleDesc.
1275 *
1276 * Note: This is only for the limited purpose of table and view creation. Not
1277 * everything is filled in. A real tuple descriptor should be obtained from
1278 * the relcache.
1279 */
1280 TupleDesc
1282 {
1284 AttrNumber attnum;
1286 TupleDesc desc;
1288 Oid atttypid;
1289 int32 atttypmod;
1290 Oid attcollation;
1293 /*
1294 * allocate a new tuple descriptor
1295 */
1302 {
1304 AclResult aclresult;
1305 Form_pg_attribute att;
1307 /*
1308 * for each entry in the list, get the name and type information from
1309 * the list and have TupleDescInitEntry fill in the attribute
1310 * information we need.
1311 */
1312 attnum++;
1332 attname)));
1338 /* Override TupleDescInitEntry's settings as requested */
1341 /* Fill in additional stuff not handled by TupleDescInitEntry */
1352 }
1355 }
1357 /*
1358 * Emit the right error or warning message for a "DROP" command issued on a
1359 * non-existent relation
1360 */
1361 static void
1363 {
1368 {
1370 {
1374 }
1375 else
1376 {
1380 }
1382 }
1385 {
1387 {
1389 {
1393 }
1394 else
1395 {
1398 }
1399 }
1400 }
1403 }
1405 /*
1406 * Emit the right error message for a "DROP" command issued on a
1407 * relation of the wrong type
1408 */
1409 static void
1411 {
1423 /* wrongkind could be something we don't have in our table... */
1429 }
1431 /*
1432 * RemoveRelations
1433 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW,
1434 * DROP MATERIALIZED VIEW, DROP FOREIGN TABLE
1435 */
1436 void
1438 {
1445 /* DROP CONCURRENTLY uses a weaker lock, and has some restrictions */
1447 {
1448 /*
1449 * Note that for temporary relations this lock may get upgraded later
1450 * on, but as no other session can access a temporary relation, this
1451 * is actually fine.
1452 */
1463 }
1465 /*
1466 * First we identify all the relations, then we delete them in a single
1467 * performMultipleDeletions() call. This is to avoid unwanted DROP
1468 * RESTRICT errors if one of the relations depends on another.
1469 */
1471 /* Determine required relkind */
1473 {
1503 }
1505 /* Lock and validate each relation; build a list of object addresses */
1509 {
1511 Oid relOid;
1512 ObjectAddress obj;
1515 /*
1516 * These next few steps are a great deal like relation_openrv, but we
1517 * don't bother building a relcache entry since we don't need it.
1518 *
1519 * Check for shared-cache-inval messages before trying to access the
1520 * relation. This is needed to cover the case where the name
1521 * identifies a rel that has been dropped and recreated since the
1522 * start of our transaction: if we don't flush the old syscache entry,
1523 * then we'll latch onto that entry and suffer an error later.
1524 */
1527 /* Look up the appropriate relation using namespace search. */
1531 /* We must initialize these fields to show that no locks are held: */
1536 RangeVarCallbackForDropRelation,
1539 /* Not there? */
1541 {
1544 }
1546 /*
1547 * Decide if concurrent mode needs to be used here or not. The
1548 * callback retrieved the rel's persistence for us.
1549 */
1552 {
1556 }
1558 /*
1559 * Concurrent index drop cannot be used with partitioned indexes,
1560 * either.
1561 */
1569 /*
1570 * If we're told to drop a partitioned index, we must acquire lock on
1571 * all the children of its parent partitioned table before proceeding.
1572 * Otherwise we'd try to lock the child index partitions before their
1573 * tables, leading to potential deadlock against other sessions that
1574 * will lock those objects in the other order.
1575 */
1579 NULL);
1581 /* OK, we're ready to delete this one */
1587 }
1592 }
1594 /*
1595 * Before acquiring a table lock, check whether we have sufficient rights.
1596 * In the case of DROP INDEX, also try to lock the table before the index.
1597 * Also, if the table to be dropped is a partition, we try to lock the parent
1598 * first.
1599 */
1600 static void
1603 {
1604 HeapTuple tuple;
1608 Form_pg_class classform;
1609 LOCKMODE heap_lockmode;
1615 /*
1616 * If we previously locked some other index's heap, and the name we're
1617 * looking up no longer refers to that relation, release the now-useless
1618 * lock.
1619 */
1621 {
1624 }
1626 /*
1627 * Similarly, if we previously locked some other partition's heap, and the
1628 * name we're looking up no longer refers to that relation, release the
1629 * now-useless lock.
1630 */
1632 {
1635 }
1637 /* Didn't find a relation, so no need for locking or permission checks. */
1647 /* Pass back some data to save lookups in RemoveRelations */
1651 /*
1652 * Both RELKIND_RELATION and RELKIND_PARTITIONED_TABLE are OBJECT_TABLE,
1653 * but RemoveRelations() can only pass one relkind for a given relation.
1654 * It chooses RELKIND_RELATION for both regular and partitioned tables.
1655 * That means we must be careful before giving the wrong type error when
1656 * the relation is RELKIND_PARTITIONED_TABLE. An equivalent problem
1657 * exists with indexes.
1658 */
1663 else
1670 /* Allow DROP to either table owner or schema owner */
1677 /*
1678 * Check the case of a system index that might have been invalidated by a
1679 * failed concurrent process and allow its drop. For the time being, this
1680 * only concerns indexes of toast relations that became invalid during a
1681 * REINDEX CONCURRENTLY process.
1682 */
1684 {
1685 HeapTuple locTuple;
1686 Form_pg_index indexform;
1691 {
1694 }
1700 /* Mark object as being an invalid index of system catalogs */
1703 }
1705 /* In the case of an invalid index, it is fine to bypass this check */
1714 /*
1715 * In DROP INDEX, attempt to acquire lock on the parent table before
1716 * locking the index. index_drop() will need this anyway, and since
1717 * regular queries lock tables before their indexes, we risk deadlock if
1718 * we do it the other way around. No error if we don't find a pg_index
1719 * entry, though --- the relation may have been dropped. Note that this
1720 * code will execute for either plain or partitioned indexes.
1721 */
1724 {
1728 }
1730 /*
1731 * Similarly, if the relation is a partition, we must acquire lock on its
1732 * parent before locking the partition. That's because queries lock the
1733 * parent before its partitions, so we risk deadlock if we do it the other
1734 * way around.
1735 */
1737 {
1741 }
1742 }
1744 /*
1745 * ExecuteTruncate
1746 * Executes a TRUNCATE command.
1747 *
1748 * This is a multi-relation truncate. We first open and grab exclusive
1749 * lock on all relations involved, checking permissions and otherwise
1750 * verifying that the relation is OK for truncation. Note that if relations
1751 * are foreign tables, at this stage, we have not yet checked that their
1752 * foreign data in external data sources are OK for truncation. These are
1753 * checked when foreign data are actually truncated later. In CASCADE mode,
1754 * relations having FK references to the targeted relations are automatically
1755 * added to the group; in RESTRICT mode, we check that all FK references are
1756 * internal to the group that's being truncated. Finally all the relations
1757 * are truncated and reindexed.
1758 */
1759 void
1761 {
1767 /*
1768 * Open, exclusive-lock, and check all the explicitly-specified relations
1769 */
1771 {
1773 Relation rel;
1775 Oid myrelid;
1780 NULL);
1782 /* don't throw error for "TRUNCATE foo, foo" */
1786 /* open the relation, we already hold a lock on it */
1789 /*
1790 * RangeVarGetRelidExtended() has done most checks with its callback,
1791 * but other checks with the now-opened Relation remain.
1792 */
1798 /* Log this relation only if needed for logical decoding */
1803 {
1810 {
1816 /* find_all_inheritors already got lock */
1819 /*
1820 * It is possible that the parent table has children that are
1821 * temp tables of other backends. We cannot safely access
1822 * such tables (because of buffering issues), and the best
1823 * thing to do is to silently ignore them. Note that this
1824 * check is the same as one of the checks done in
1825 * truncate_check_activity() called below, still it is kept
1826 * here for simplicity.
1827 */
1829 {
1832 }
1834 /*
1835 * Inherited TRUNCATE commands perform access permission
1836 * checks on the parent table only. So we skip checking the
1837 * children's permissions and don't call
1838 * truncate_check_perms() here.
1839 */
1846 /* Log this relation only if needed for logical decoding */
1849 }
1850 }
1855 errhint("Do not specify the ONLY keyword, or use TRUNCATE ONLY on the partitions directly.")));
1856 }
1861 /* And close the rels */
1863 {
1867 }
1868 }
1870 /*
1871 * ExecuteTruncateGuts
1872 *
1873 * Internal implementation of TRUNCATE. This is called by the actual TRUNCATE
1874 * command (see above) as well as replication subscribers that execute a
1875 * replicated TRUNCATE action.
1876 *
1877 * explicit_rels is the list of Relations to truncate that the command
1878 * specified. relids is the list of Oids corresponding to explicit_rels.
1879 * relids_logged is the list of Oids (a subset of relids) that require
1880 * WAL-logging. This is all a bit redundant, but the existing callers have
1881 * this information handy in this form.
1882 */
1883 void
1889 {
1896 SubTransactionId mySubid;
1900 /*
1901 * Check the explicitly-specified relations.
1902 *
1903 * In CASCADE mode, suck in all referencing relations as well. This
1904 * requires multiple iterations to find indirectly-dependent relations. At
1905 * each phase, we need to exclusive-lock new rels before looking for their
1906 * dependencies, else we might miss something. Also, we check each rel as
1907 * soon as we open it, to avoid a faux pas such as holding lock for a long
1908 * time on a rel we have no permissions for.
1909 */
1912 {
1914 {
1922 {
1924 Relation rel;
1936 /* Log this relation only if needed for logical decoding */
1939 }
1940 }
1941 }
1943 /*
1944 * Check foreign key references. In CASCADE mode, this should be
1945 * unnecessary since we just pulled in all the references; but as a
1946 * cross-check, do it anyway if in an Assert-enabled build.
1947 */
1948 #ifdef USE_ASSERT_CHECKING
1950 #else
1953 #endif
1955 /*
1956 * If we are asked to restart sequences, find all the sequences, lock them
1957 * (we need AccessExclusiveLock for ResetSequence), and check permissions.
1958 * We want to do this early since it's pointless to do all the truncation
1959 * work only to fail on sequence permissions.
1960 */
1962 {
1964 {
1970 {
1972 Relation seq_rel;
1976 /* This check must match AlterSequence! */
1984 }
1985 }
1986 }
1988 /* Prepare to catch AFTER triggers. */
1991 /*
1992 * To fire triggers, we'll need an EState as well as a ResultRelInfo for
1993 * each relation. We don't need to call ExecOpenIndices, though.
1994 *
1995 * We put the ResultRelInfos in the es_opened_result_relations list, even
1996 * though we don't have a range table and don't populate the
1997 * es_result_relations array. That's a bit bogus, but it's enough to make
1998 * ExecGetTriggerResultRel() find them.
1999 */
2005 {
2009 rel,
2011 NULL,
2015 resultRelInfo++;
2016 }
2018 /*
2019 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
2020 * truncating (this is because one of them might throw an error). Also, if
2021 * we were to allow them to prevent statement execution, that would need
2022 * to be handled here.
2023 */
2026 {
2027 UserContext ucxt;
2035 resultRelInfo++;
2036 }
2038 /*
2039 * OK, truncate each table.
2040 */
2044 {
2047 /* Skip partitioned tables as there is nothing to do */
2051 /*
2052 * Build the lists of foreign tables belonging to each foreign server
2053 * and pass each list to the foreign data wrapper's callback function,
2054 * so that each server can truncate its all foreign tables in bulk.
2055 * Each list is saved as a single entry in a hash table that uses the
2056 * server OID as lookup key.
2057 */
2059 {
2064 /* First time through, initialize hashtable for foreign tables */
2066 {
2067 HASHCTL hctl;
2078 }
2080 /* Find or create cached entry for the foreign table */
2085 /*
2086 * Save the foreign table in the entry of the server that the
2087 * foreign table belongs to.
2088 */
2091 }
2093 /*
2094 * Normally, we need a transaction-safe truncation here. However, if
2095 * the table was either created in the current (sub)transaction or has
2096 * a new relfilenumber in the current (sub)transaction, then we can
2097 * just truncate it in-place, because a rollback would cause the whole
2098 * table or the current physical file to be thrown away anyway.
2099 */
2102 {
2103 /* Immediate, non-rollbackable truncation is OK */
2105 }
2106 else
2107 {
2108 Oid heap_relid;
2109 Oid toast_relid;
2112 /*
2113 * This effectively deletes all rows in the table, and may be done
2114 * in a serializable transaction. In that case we must record a
2115 * rw-conflict in to this transaction from each transaction
2116 * holding a predicate lock on the table.
2117 */
2120 /*
2121 * Need the full transaction-safe pushups.
2122 *
2123 * Create a new empty storage file for the relation, and assign it
2124 * as the relfilenumber value. The old storage file is scheduled
2125 * for deletion at commit.
2126 */
2131 /*
2132 * The same for the toast table, if any.
2133 */
2136 {
2138 AccessExclusiveLock);
2143 }
2145 /*
2146 * Reconstruct the indexes to match, and we're done.
2147 */
2150 }
2153 }
2155 /* Now go through the hash table, and truncate foreign tables */
2157 {
2159 HASH_SEQ_STATUS seq;
2164 {
2166 {
2169 /* truncate_check_rel() has checked that already */
2173 behavior,
2174 restart_seqs);
2175 }
2176 }
2178 {
2180 }
2182 }
2184 /*
2185 * Restart owned sequences if we were asked to.
2186 */
2188 {
2192 }
2194 /*
2195 * Write a WAL record to allow this set of actions to be logically
2196 * decoded.
2197 *
2198 * Assemble an array of relids so we can write a single WAL record for the
2199 * whole action.
2200 */
2202 {
2203 xl_heap_truncate xlrec;
2206 /* should only get here if wal_level >= logical */
2228 }
2230 /*
2231 * Process all AFTER STATEMENT TRUNCATE triggers.
2232 */
2235 {
2236 UserContext ucxt;
2244 resultRelInfo++;
2245 }
2247 /* Handle queued AFTER triggers */
2250 /* We can clean up the EState now */
2253 /*
2254 * Close any rels opened by CASCADE (can't do this while EState still
2255 * holds refs)
2256 */
2259 {
2263 }
2264 }
2266 /*
2267 * Check that a given relation is safe to truncate. Subroutine for
2268 * ExecuteTruncate() and RangeVarCallbackForTruncate().
2269 */
2270 static void
2272 {
2275 /*
2276 * Only allow truncate on regular tables, foreign tables using foreign
2277 * data wrappers supporting TRUNCATE and partitioned tables (although, the
2278 * latter are only being included here for the following checks; no
2279 * physical truncation will occur in their case.).
2280 */
2282 {
2290 relname)));
2291 }
2298 /*
2299 * Most system catalogs can't be truncated at all, or at least not unless
2300 * allow_system_table_mods=on. As an exception, however, we allow
2301 * pg_largeobject to be truncated as part of pg_upgrade, because we need
2302 * to change its relfilenode to match the old cluster, and allowing a
2303 * TRUNCATE command to be executed is the easiest way of doing that.
2304 */
2310 relname)));
2313 }
2315 /*
2316 * Check that current user has the permission to truncate given relation.
2317 */
2318 static void
2320 {
2322 AclResult aclresult;
2324 /* Permissions checks */
2328 relname);
2329 }
2331 /*
2332 * Set of extra sanity checks to check if a given relation is safe to
2333 * truncate. This is split with truncate_check_rel() as
2334 * RangeVarCallbackForTruncate() cannot open a Relation yet.
2335 */
2336 static void
2338 {
2339 /*
2340 * Don't allow truncate on temp tables of other backends ... their local
2341 * buffer manager is not going to cope.
2342 */
2348 /*
2349 * Also check for active uses of the relation in the current transaction,
2350 * including open scans and pending AFTER trigger events.
2351 */
2353 }
2355 /*
2356 * storage_name
2357 * returns the name corresponding to a typstorage/attstorage enum value
2358 */
2361 {
2363 {
2374 }
2375 }
2377 /*----------
2378 * MergeAttributes
2379 * Returns new schema given initial schema and superclasses.
2380 *
2381 * Input arguments:
2382 * 'columns' is the column/attribute definition for the table. (It's a list
2383 * of ColumnDef's.) It is destructively changed.
2384 * 'supers' is a list of OIDs of parent relations, already locked by caller.
2385 * 'relpersistence' is the persistence type of the table.
2386 * 'is_partition' tells if the table is a partition.
2387 *
2388 * Output arguments:
2389 * 'supconstr' receives a list of constraints belonging to the parents,
2390 * updated as necessary to be valid for the child.
2391 *
2392 * Return value:
2393 * Completed schema list.
2394 *
2395 * Notes:
2396 * The order in which the attributes are inherited is very important.
2397 * Intuitively, the inherited attributes should come first. If a table
2398 * inherits from multiple parents, the order of those attributes are
2399 * according to the order of the parents specified in CREATE TABLE.
2400 *
2401 * Here's an example:
2402 *
2403 * create table person (name text, age int4, location point);
2404 * create table emp (salary int4, manager text) inherits(person);
2405 * create table student (gpa float8) inherits (person);
2406 * create table stud_emp (percent int4) inherits (emp, student);
2407 *
2408 * The order of the attributes of stud_emp is:
2409 *
2410 * person {1:name, 2:age, 3:location}
2411 * / \
2412 * {6:gpa} student emp {4:salary, 5:manager}
2413 * \ /
2414 * stud_emp {7:percent}
2415 *
2416 * If the same attribute name appears multiple times, then it appears
2417 * in the result table in the proper location for its first appearance.
2418 *
2419 * Constraints (including not-null constraints) for the child table
2420 * are the union of all relevant constraints, from both the child schema
2421 * and parent tables.
2422 *
2423 * The default value for a child column is defined as:
2424 * (1) If the child schema specifies a default, that value is used.
2425 * (2) If neither the child nor any parent specifies a default, then
2426 * the column will not have a default.
2427 * (3) If conflicting defaults are inherited from different parents
2428 * (and not overridden by the child), an error is raised.
2429 * (4) Otherwise the inherited default is used.
2430 *
2431 * Note that the default-value infrastructure is used for generated
2432 * columns' expressions too, so most of the preceding paragraph applies
2433 * to generation expressions too. We insist that a child column be
2434 * generated if and only if its parent(s) are, but it need not have
2435 * the same generation expression.
2436 *----------
2437 */
2441 {
2450 /*
2451 * Check for and reject tables with too many columns. We perform this
2452 * check relatively early for two reasons: (a) we don't run the risk of
2453 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
2454 * okay if we're processing <= 1600 columns, but could take minutes to
2455 * execute if the user attempts to create a table with hundreds of
2456 * thousands of columns.
2457 *
2458 * Note that we also need to check that we do not exceed this figure after
2459 * including columns from inherited relations.
2460 */
2465 MaxHeapAttributeNumber)));
2467 /*
2468 * Check for duplicate names in the explicit list of attributes.
2469 *
2470 * Although we might consider merging such entries in the same way that we
2471 * handle name conflicts for inherited attributes, it seems to make more
2472 * sense to assume such conflicts are errors.
2473 *
2474 * We don't use foreach() here because we have two nested loops over the
2475 * columns list, with possible element deletions in the inner one. If we
2476 * used foreach_delete_current() it could only fix up the state of one of
2477 * the loops, so it seems cleaner to use looping over list indexes for
2478 * both loops. Note that any deletion will happen beyond where the outer
2479 * loop is, so its index never needs adjustment.
2480 */
2482 {
2486 {
2487 /*
2488 * Typed table column option that does not belong to a column from
2489 * the type. This works because the columns from the type come
2490 * first in the list. (We omit this check for partition column
2491 * lists; those are processed separately below.)
2492 */
2497 }
2499 /* restpos scans all entries beyond coldef; incr is in loop body */
2501 {
2505 {
2507 {
2508 /*
2509 * merge the column options into the column from the type
2510 */
2517 }
2518 else
2523 }
2524 else
2525 restpos++;
2526 }
2527 }
2529 /*
2530 * In case of a partition, there are no new column definitions, only dummy
2531 * ColumnDefs created for column constraints. Set them aside for now and
2532 * process them at the end.
2533 */
2535 {
2538 }
2540 /*
2541 * Scan the parents left-to-right, and merge their attributes to form a
2542 * list of inherited columns (inh_columns).
2543 */
2546 {
2548 Relation relation;
2549 TupleDesc tupleDesc;
2557 /* caller already got lock */
2560 /*
2561 * Check for active uses of the parent partitioned table in the
2562 * current transaction, such as being used in some manner by an
2563 * enclosing command.
2564 */
2568 /*
2569 * We do not allow partitioned tables and partitions to participate in
2570 * regular inheritance.
2571 */
2591 /*
2592 * If the parent is permanent, so must be all of its partitions. Note
2593 * that inheritance allows that case.
2594 */
2603 /* Permanent rels cannot inherit from temporary ones */
2613 /* If existing rel is temp, it must belong to this session */
2622 /*
2623 * We should have an UNDER permission flag for this, but for now,
2624 * demand that creator of a child table own the parent.
2625 */
2633 /*
2634 * newattmap->attnums[] will contain the child-table attribute numbers
2635 * for the attributes of this parent table. (They are not the same
2636 * for parents after the first one, nor if we have dropped columns.)
2637 */
2640 /* We can't process inherited defaults until newattmap is complete. */
2644 parent_attno++)
2645 {
2653 /*
2654 * Ignore dropped columns in the parent.
2655 */
2659 /*
2660 * Create new column definition
2661 */
2671 /*
2672 * Regular inheritance children are independent enough not to
2673 * inherit identity columns. But partitions are integral part of
2674 * a partitioned table and inherit identity column.
2675 */
2679 /*
2680 * Does it match some previously considered column from another
2681 * parent?
2682 */
2685 {
2686 /*
2687 * Yes, try to merge the two column definitions.
2688 */
2693 /*
2694 * Partitions have only one parent, so conflict should never
2695 * occur.
2696 */
2698 }
2699 else
2700 {
2701 /*
2702 * No, create a new inherited column
2703 */
2710 }
2712 /*
2713 * Locate default/generation expression if any
2714 */
2716 {
2724 /*
2725 * If it's a GENERATED default, it might contain Vars that
2726 * need to be mapped to the inherited column(s)' new numbers.
2727 * We can't do that till newattmap is ready, so just remember
2728 * all the inherited default expressions for the moment.
2729 */
2732 }
2733 }
2735 /*
2736 * Now process any inherited default expressions, adjusting attnos
2737 * using the completed newattmap map.
2738 */
2740 {
2745 /* Adjust Vars to match new table's column numbering */
2748 newattmap,
2751 /*
2752 * For the moment we have to reject whole-row variables. We could
2753 * convert them, if we knew the new table's rowtype OID, but that
2754 * hasn't been assigned yet. (A variable could only appear in a
2755 * generation expression, so the error message is correct.)
2756 */
2761 errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
2765 /*
2766 * If we already had a default from some prior parent, check to
2767 * see if they are the same. If so, no problem; if not, mark the
2768 * column as having a bogus default. Below, we will complain if
2769 * the bogus default isn't overridden by the child columns.
2770 */
2775 {
2778 }
2779 }
2781 /*
2782 * Now copy the CHECK constraints of this parent, adjusting attnos
2783 * using the completed newattmap map. Identically named constraints
2784 * are merged if possible, else we throw error.
2785 */
2787 {
2791 {
2796 /* ignore if the constraint is non-inheritable */
2800 /* Adjust Vars to match new table's column numbering */
2803 newattmap,
2806 /*
2807 * For the moment we have to reject whole-row variables. We
2808 * could convert them, if we knew the new table's rowtype OID,
2809 * but that hasn't been assigned yet.
2810 */
2816 name,
2820 }
2821 }
2825 /*
2826 * Close the parent rel, but keep our lock on it until xact commit.
2827 * That will prevent someone else from deleting or ALTERing the parent
2828 * before the child is committed.
2829 */
2831 }
2833 /*
2834 * If we had no inherited attributes, the result columns are just the
2835 * explicitly declared columns. Otherwise, we need to merge the declared
2836 * columns into the inherited column list. Although, we never have any
2837 * explicitly declared columns if the table is a partition.
2838 */
2840 {
2844 {
2849 /*
2850 * Partitions have only one parent and have no column definitions
2851 * of their own, so conflict should never occur.
2852 */
2855 newcol_attno++;
2857 /*
2858 * Does it match some inherited column?
2859 */
2862 {
2863 /*
2864 * Yes, try to merge the two column definitions.
2865 */
2867 }
2868 else
2869 {
2870 /*
2871 * No, attach new column unchanged to result columns.
2872 */
2874 }
2875 }
2879 /*
2880 * Check that we haven't exceeded the legal # of columns after merging
2881 * in inherited columns.
2882 */
2887 MaxHeapAttributeNumber)));
2888 }
2890 /*
2891 * Now that we have the column definition list for a partition, we can
2892 * check whether the columns referenced in the column constraint specs
2893 * actually exist. Also, we merge parent's not-null constraints and
2894 * defaults into each corresponding column definition.
2895 */
2897 {
2899 {
2905 {
2909 {
2913 /*
2914 * Check for conflicts related to generated columns.
2915 *
2916 * Same rules as above: generated-ness has to match the
2917 * parent, but the contents of the generation expression
2918 * can be different.
2919 */
2921 {
2932 }
2933 else
2934 {
2941 }
2943 /*
2944 * Override the parent's default value for this column
2945 * (coldef->cooked_default) with the partition's local
2946 * definition (restdef->raw_default), if there's one. It
2947 * should be physically impossible to get a cooked default
2948 * in the local definition or a raw default in the
2949 * inherited definition, but make sure they're nulls, for
2950 * future-proofing.
2951 */
2955 {
2958 }
2959 }
2960 }
2962 /* complain for constraints on columns not in parent */
2968 }
2969 }
2971 /*
2972 * If we found any conflicting parent default values, check to make sure
2973 * they were overridden by the child.
2974 */
2976 {
2978 {
2982 {
2989 else
2995 }
2996 }
2997 }
3002 }
3005 /*
3006 * MergeCheckConstraint
3007 * Try to merge an inherited CHECK constraint with previous ones
3008 *
3009 * If we inherit identically-named constraints from multiple parents, we must
3010 * merge them, or throw an error if they don't have identical definitions.
3011 *
3012 * constraints is a list of CookedConstraint structs for previous constraints.
3013 *
3014 * If the new constraint matches an existing one, then the existing
3015 * constraint's inheritance count is updated. If there is a conflict (same
3016 * name but different expression), throw an error. If the constraint neither
3017 * matches nor conflicts with an existing one, a new constraint is appended to
3018 * the list.
3019 */
3022 {
3027 {
3032 /* Non-matching names never conflict */
3037 {
3038 /* OK to merge constraint with existing */
3045 }
3050 name)));
3051 }
3053 /*
3054 * Constraint couldn't be merged with an existing one and also didn't
3055 * conflict with an existing one, so add it as a new one to the list.
3056 */
3063 }
3065 /*
3066 * MergeChildAttribute
3067 * Merge given child attribute definition into given inherited attribute.
3068 *
3069 * Input arguments:
3070 * 'inh_columns' is the list of inherited ColumnDefs.
3071 * 'exist_attno' is the number of the inherited attribute in inh_columns
3072 * 'newcol_attno' is the attribute number in child table's schema definition
3073 * 'newdef' is the column/attribute definition from the child table.
3074 *
3075 * The ColumnDef in 'inh_columns' list is modified. The child attribute's
3076 * ColumnDef remains unchanged.
3077 *
3078 * Notes:
3079 * - The attribute is merged according to the rules laid out in the prologue
3080 * of MergeAttributes().
3081 * - If matching inherited attribute exists but the child attribute can not be
3082 * merged into it, the function throws respective errors.
3083 * - A partition can not have its own column definitions. Hence this function
3084 * is applicable only to a regular inheritance child.
3085 */
3086 static void
3087 MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef)
3088 {
3091 Oid inhtypeid,
3092 newtypeid;
3093 int32 inhtypmod,
3094 newtypmod;
3095 Oid inhcollid,
3096 newcollid;
3101 attributeName)));
3102 else
3109 /*
3110 * Must have the same type and typmod
3111 */
3118 attributeName),
3123 /*
3124 * Must have the same collation
3125 */
3132 attributeName),
3137 /*
3138 * Identity is never inherited by a regular inheritance child. Pick
3139 * child's identity definition if there's one.
3140 */
3143 /*
3144 * Copy storage parameter
3145 */
3152 attributeName),
3157 /*
3158 * Copy compression parameter
3159 */
3163 {
3168 attributeName),
3170 }
3172 /*
3173 * Merge of not-null constraints = OR 'em together
3174 */
3177 /*
3178 * Check for conflicts related to generated columns.
3179 *
3180 * If the parent column is generated, the child column will be made a
3181 * generated column if it isn't already. If it is a generated column,
3182 * we'll take its generation expression in preference to the parent's. We
3183 * must check that the child column doesn't specify a default value or
3184 * identity, which matches the rules for a single column in
3185 * parse_utilcmd.c.
3186 *
3187 * Conversely, if the parent column is not generated, the child column
3188 * can't be either. (We used to allow that, but it results in being able
3189 * to override the generation expression via UPDATEs through the parent.)
3190 */
3192 {
3203 }
3204 else
3205 {
3212 }
3214 /*
3215 * If new def has a default, override previous default
3216 */
3218 {
3221 }
3223 /* Mark the column as locally defined */
3225 }
3227 /*
3228 * MergeInheritedAttribute
3229 * Merge given parent attribute definition into specified attribute
3230 * inherited from the previous parents.
3231 *
3232 * Input arguments:
3233 * 'inh_columns' is the list of previously inherited ColumnDefs.
3234 * 'exist_attno' is the number the existing matching attribute in inh_columns.
3235 * 'newdef' is the new parent column/attribute definition to be merged.
3236 *
3237 * The matching ColumnDef in 'inh_columns' list is modified and returned.
3238 *
3239 * Notes:
3240 * - The attribute is merged according to the rules laid out in the prologue
3241 * of MergeAttributes().
3242 * - If matching inherited attribute exists but the new attribute can not be
3243 * merged into it, the function throws respective errors.
3244 * - A partition inherits from only a single parent. Hence this function is
3245 * applicable only to a regular inheritance.
3246 */
3251 {
3254 Oid prevtypeid,
3255 newtypeid;
3256 int32 prevtypmod,
3257 newtypmod;
3258 Oid prevcollid,
3259 newcollid;
3263 attributeName)));
3266 /*
3267 * Must have the same type and typmod
3268 */
3275 attributeName),
3280 /*
3281 * Merge of not-null constraints = OR 'em together
3282 */
3285 /*
3286 * Must have the same collation
3287 */
3294 attributeName),
3299 /*
3300 * Copy/check storage parameter
3301 */
3308 attributeName),
3313 /*
3314 * Copy/check compression parameter
3315 */
3319 {
3324 attributeName),
3327 }
3329 /*
3330 * Check for GENERATED conflicts
3331 */
3336 attributeName)));
3338 /*
3339 * Default and other constraints are handled by the caller.
3340 */
3349 }
3351 /*
3352 * StoreCatalogInheritance
3353 * Updates the system catalogs with proper inheritance information.
3354 *
3355 * supers is a list of the OIDs of the new relation's direct ancestors.
3356 */
3357 static void
3360 {
3361 Relation relation;
3362 int32 seqNumber;
3365 /*
3366 * sanity checks
3367 */
3373 /*
3374 * Store INHERITS information in pg_inherits using direct ancestors only.
3375 * Also enter dependencies on the direct ancestors, and make sure they are
3376 * marked with relhassubclass = true.
3377 *
3378 * (Once upon a time, both direct and indirect ancestors were found here
3379 * and then entered into pg_ipl. Since that catalog doesn't exist
3380 * anymore, there's no need to look for indirect ancestors.)
3381 */
3386 {
3390 child_is_partition);
3391 seqNumber++;
3392 }
3395 }
3397 /*
3398 * Make catalog entries showing relationId as being an inheritance child
3399 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
3400 */
3401 static void
3405 {
3406 ObjectAddress childobject,
3407 parentobject;
3409 /* store the pg_inherits row */
3412 /*
3413 * Store a dependency too
3414 */
3425 /*
3426 * Post creation hook of this inheritance. Since object_access_hook
3427 * doesn't take multiple object identifiers, we relay oid of parent
3428 * relation using auxiliary_id argument.
3429 */
3434 /*
3435 * Mark the parent as having subclasses.
3436 */
3438 }
3440 /*
3441 * Look for an existing column entry with the given name.
3442 *
3443 * Returns the index (starting with 1) if attribute already exists in columns,
3444 * 0 if it doesn't.
3445 */
3446 static int
3448 {
3453 {
3457 i++;
3458 }
3460 }
3463 /*
3464 * SetRelationHasSubclass
3465 * Set the value of the relation's relhassubclass field in pg_class.
3466 *
3467 * It's always safe to set this field to true, because all SQL commands are
3468 * ready to see true and then find no children. On the other hand, commands
3469 * generally assume zero children if this is false.
3470 *
3471 * Caller must hold any self-exclusive lock until end of transaction. If the
3472 * new value is false, caller must have acquired that lock before reading the
3473 * evidence that justified the false value. That way, it properly waits if
3474 * another backend is simultaneously concluding no need to change the tuple
3475 * (new and old values are true).
3476 *
3477 * NOTE: an important side-effect of this operation is that an SI invalidation
3478 * message is sent out to all backends --- including me --- causing plans
3479 * referencing the relation to be rebuilt with the new list of children.
3480 * This must happen even if we find that no change is needed in the pg_class
3481 * row.
3482 */
3483 void
3485 {
3486 Relation relationRelation;
3487 HeapTuple tuple;
3488 Form_pg_class classtuple;
3495 /*
3496 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
3497 */
3505 {
3508 }
3509 else
3510 {
3511 /* no need to change tuple, but force relcache rebuild anyway */
3513 }
3517 }
3519 /*
3520 * CheckRelationTableSpaceMove
3521 * Check if relation can be moved to new tablespace.
3522 *
3523 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3524 *
3525 * Returns true if the relation can be moved to the new tablespace; raises
3526 * an error if it is not possible to do the move; returns false if the move
3527 * would have no effect.
3528 */
3529 bool
3531 {
3532 Oid oldTableSpaceId;
3534 /*
3535 * No work if no change in tablespace. Note that MyDatabaseTableSpace is
3536 * stored as 0.
3537 */
3543 /*
3544 * We cannot support moving mapped relations into different tablespaces.
3545 * (In particular this eliminates all shared catalogs.)
3546 */
3553 /* Cannot move a non-shared relation into pg_global */
3559 /*
3560 * Do not allow moving temp tables of other backends ... their local
3561 * buffer manager is not going to cope.
3562 */
3569 }
3571 /*
3572 * SetRelationTableSpace
3573 * Set new reltablespace and relfilenumber in pg_class entry.
3574 *
3575 * newTableSpaceId is the new tablespace for the relation, and
3576 * newRelFilenumber its new filenumber. If newRelFilenumber is
3577 * InvalidRelFileNumber, this field is not updated.
3578 *
3579 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3580 *
3581 * The caller of this routine had better check if a relation can be
3582 * moved to this new tablespace by calling CheckRelationTableSpaceMove()
3583 * first, and is responsible for making the change visible with
3584 * CommandCounterIncrement().
3585 */
3586 void
3588 Oid newTableSpaceId,
3589 RelFileNumber newRelFilenumber)
3590 {
3591 Relation pg_class;
3592 HeapTuple tuple;
3593 Form_pg_class rd_rel;
3598 /* Get a modifiable copy of the relation's pg_class row. */
3606 /* Update the pg_class row. */
3613 /*
3614 * Record dependency on tablespace. This is only required for relations
3615 * that have no physical storage.
3616 */
3623 }
3625 /*
3626 * renameatt_check - basic sanity checks before attribute rename
3627 */
3628 static void
3630 {
3638 /*
3639 * Renaming the columns of sequences or toast tables doesn't actually
3640 * break anything from the system's point of view, since internal
3641 * references are by attnum. But it doesn't seem right to allow users to
3642 * change names that are hardcoded into the system, hence the following
3643 * restriction.
3644 */
3659 /*
3660 * permissions checking. only the owner of a class can change its schema.
3661 */
3670 }
3672 /*
3673 * renameatt_internal - workhorse for renameatt
3674 *
3675 * Return value is the attribute number in the 'myrelid' relation.
3676 */
3677 static AttrNumber
3684 DropBehavior behavior)
3685 {
3686 Relation targetrelation;
3687 Relation attrelation;
3688 HeapTuple atttup;
3689 Form_pg_attribute attform;
3690 AttrNumber attnum;
3692 /*
3693 * Grab an exclusive lock on the target table, which we will NOT release
3694 * until end of transaction.
3695 */
3699 /*
3700 * if the 'recurse' flag is set then we are supposed to rename this
3701 * attribute in all classes that inherit from 'relname' (as well as in
3702 * 'relname').
3703 *
3704 * any permissions or problems with duplicate attributes will cause the
3705 * whole transaction to abort, which is what we want -- all or nothing.
3706 */
3708 {
3714 /*
3715 * we need the number of parents for each child so that the recursive
3716 * calls to renameatt() can determine whether there are any parents
3717 * outside the inheritance hierarchy being processed.
3718 */
3722 /*
3723 * find_all_inheritors does the recursive search of the inheritance
3724 * hierarchy, so all we have to do is process all of the relids in the
3725 * list that it returns.
3726 */
3728 {
3734 /* note we need not recurse again */
3736 }
3737 }
3738 else
3739 {
3740 /*
3741 * If we are told not to recurse, there had better not be any child
3742 * tables; else the rename would put them out of step.
3743 *
3744 * expected_parents will only be 0 if we are not already recursing.
3745 */
3751 oldattname)));
3752 }
3754 /* rename attributes in typed tables of composite type */
3756 {
3762 behavior);
3766 }
3775 oldattname)));
3783 oldattname)));
3785 /*
3786 * if the attribute is inherited, forbid the renaming. if this is a
3787 * top-level call to renameatt(), then expected_parents will be 0, so the
3788 * effect of this code will be to prohibit the renaming if the attribute
3789 * is inherited at all. if this is a recursive call to renameatt(),
3790 * expected_parents will be the number of parents the current relation has
3791 * within the inheritance hierarchy being processed, so we'll prohibit the
3792 * renaming only if there are additional parents from elsewhere.
3793 */
3798 oldattname)));
3800 /* new name should not already exist */
3803 /* apply the update */
3817 }
3819 /*
3820 * Perform permissions and integrity checks before acquiring a relation lock.
3821 */
3822 static void
3825 {
3826 HeapTuple tuple;
3827 Form_pg_class form;
3835 }
3837 /*
3838 * renameatt - changes the name of an attribute in a relation
3839 *
3840 * The returned ObjectAddress is that of the renamed column.
3841 */
3842 ObjectAddress
3844 {
3845 Oid relid;
3846 AttrNumber attnum;
3847 ObjectAddress address;
3849 /* lock level taken here should match renameatt_internal */
3852 RangeVarCallbackForRenameAttribute,
3853 NULL);
3856 {
3861 }
3863 attnum =
3875 }
3877 /*
3878 * same logic as renameatt_internal
3879 */
3880 static ObjectAddress
3882 Oid mytypid,
3888 {
3890 Oid constraintOid;
3891 HeapTuple tuple;
3892 Form_pg_constraint con;
3893 ObjectAddress address;
3898 {
3900 }
3901 else
3902 {
3905 /*
3906 * don't tell it whether we're recursing; we allow changing typed
3907 * tables here
3908 */
3912 }
3917 constraintOid);
3921 {
3923 {
3933 {
3940 rename_constraint_internal(childrelid, InvalidOid, oldconname, newconname, false, true, numparents);
3941 }
3942 }
3943 else
3944 {
3950 oldconname)));
3951 }
3957 oldconname)));
3958 }
3964 /* rename the index; this renames the constraint as well */
3966 else
3974 {
3975 /*
3976 * Invalidate relcache so as others can see the new constraint name.
3977 */
3981 }
3984 }
3986 ObjectAddress
3988 {
3993 {
3994 Relation rel;
3995 HeapTuple tup;
4005 }
4006 else
4007 {
4008 /* lock level taken here should match rename_constraint_internal */
4011 RangeVarCallbackForRenameAttribute,
4012 NULL);
4014 {
4019 }
4020 }
4022 return
4030 }
4032 /*
4033 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW/MATERIALIZED VIEW/FOREIGN TABLE
4034 * RENAME
4035 */
4036 ObjectAddress
4038 {
4040 Oid relid;
4041 ObjectAddress address;
4043 /*
4044 * Grab an exclusive lock on the target table, index, sequence, view,
4045 * materialized view, or foreign table, which we will NOT release until
4046 * end of transaction.
4047 *
4048 * Lock level used here should match RenameRelationInternal, to avoid lock
4049 * escalation. However, because ALTER INDEX can be used with any relation
4050 * type, we mustn't believe without verification.
4051 */
4053 {
4054 LOCKMODE lockmode;
4062 RangeVarCallbackForAlterRelation,
4066 {
4071 }
4073 /*
4074 * We allow mismatched statement and object types (e.g., ALTER INDEX
4075 * to rename a table), but we might've used the wrong lock level. If
4076 * that happens, retry with the correct lock level. We don't bother
4077 * if we already acquired AccessExclusiveLock with an index, however.
4078 */
4087 }
4089 /* Do the work */
4095 }
4097 /*
4098 * RenameRelationInternal - change the name of a relation
4099 */
4100 void
4102 {
4103 Relation targetrelation;
4105 HeapTuple reltup;
4106 Form_pg_class relform;
4107 Oid namespaceId;
4109 /*
4110 * Grab a lock on the target relation, which we will NOT release until end
4111 * of transaction. We need at least a self-exclusive lock so that
4112 * concurrent DDL doesn't overwrite the rename if they start updating
4113 * while still seeing the old version. The lock also guards against
4114 * triggering relcache reloads in concurrent sessions, which might not
4115 * handle this information changing under them. For indexes, we can use a
4116 * reduced lock level because RelationReloadIndexInfo() handles indexes
4117 * specially.
4118 */
4119 targetrelation = relation_open(myrelid, is_index ? ShareUpdateExclusiveLock : AccessExclusiveLock);
4122 /*
4123 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
4124 */
4136 newrelname)));
4138 /*
4139 * RenameRelation is careful not to believe the caller's idea of the
4140 * relation kind being handled. We don't have to worry about this, but
4141 * let's not be totally oblivious to it. We can process an index as
4142 * not-an-index, but not the other way around.
4143 */
4148 /*
4149 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
4150 * because it's a copy...)
4151 */
4162 /*
4163 * Also rename the associated type, if any.
4164 */
4169 /*
4170 * Also rename the associated constraint, if any.
4171 */
4174 {
4179 }
4181 /*
4182 * Close rel, but keep lock!
4183 */
4185 }
4187 /*
4188 * ResetRelRewrite - reset relrewrite
4189 */
4190 void
4192 {
4194 HeapTuple reltup;
4195 Form_pg_class relform;
4197 /*
4198 * Find relation's pg_class tuple.
4199 */
4207 /*
4208 * Update pg_class tuple.
4209 */
4216 }
4218 /*
4219 * Disallow ALTER TABLE (and similar commands) when the current backend has
4220 * any open reference to the target table besides the one just acquired by
4221 * the calling command; this implies there's an open cursor or active plan.
4222 * We need this check because our lock doesn't protect us against stomping
4223 * on our own foot, only other people's feet!
4224 *
4225 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
4226 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
4227 * possibly be relaxed to only error out for certain types of alterations.
4228 * But the use-case for allowing any of these things is not obvious, so we
4229 * won't work hard at it for now.
4230 *
4231 * We also reject these commands if there are any pending AFTER trigger events
4232 * for the rel. This is certainly necessary for the rewriting variants of
4233 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
4234 * events would try to fetch the wrong tuples. It might be overly cautious
4235 * in other cases, but again it seems better to err on the side of paranoia.
4236 *
4237 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
4238 * we are worried about active indexscans on the index. The trigger-event
4239 * check can be skipped, since we are doing no damage to the parent table.
4240 *
4241 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
4242 */
4243 void
4245 {
4252 /* translator: first %s is a SQL command, eg ALTER TABLE */
4261 /* translator: first %s is a SQL command, eg ALTER TABLE */
4264 }
4266 /*
4267 * CheckAlterTableIsSafe
4268 * Verify that it's safe to allow ALTER TABLE on this relation.
4269 *
4270 * This consists of CheckTableNotInUse() plus a check that the relation
4271 * isn't another session's temp table. We must split out the temp-table
4272 * check because there are callers of CheckTableNotInUse() that don't want
4273 * that, notably DROP TABLE. (We must allow DROP or we couldn't clean out
4274 * an orphaned temp schema.) Compare truncate_check_activity().
4275 */
4276 static void
4278 {
4279 /*
4280 * Don't allow ALTER on temp tables of other backends. Their local buffer
4281 * manager is not going to cope if we need to change the table's contents.
4282 * Even if we don't, there may be optimizations that assume temp tables
4283 * aren't subject to such interference.
4284 */
4290 /*
4291 * Also check for active uses of the relation in the current transaction,
4292 * including open scans and pending AFTER trigger events.
4293 */
4295 }
4297 /*
4298 * AlterTableLookupRelation
4299 * Look up, and lock, the OID for the relation named by an alter table
4300 * statement.
4301 */
4302 Oid
4304 {
4307 RangeVarCallbackForAlterRelation,
4309 }
4311 /*
4312 * AlterTable
4313 * Execute ALTER TABLE, which can be a list of subcommands
4314 *
4315 * ALTER TABLE is performed in three phases:
4316 * 1. Examine subcommands and perform pre-transformation checking.
4317 * 2. Validate and transform subcommands, and update system catalogs.
4318 * 3. Scan table(s) to check new constraints, and optionally recopy
4319 * the data into new table(s).
4320 * Phase 3 is not performed unless one or more of the subcommands requires
4321 * it. The intention of this design is to allow multiple independent
4322 * updates of the table schema to be performed with only one pass over the
4323 * data.
4324 *
4325 * ATPrepCmd performs phase 1. A "work queue" entry is created for
4326 * each table to be affected (there may be multiple affected tables if the
4327 * commands traverse a table inheritance hierarchy). Also we do preliminary
4328 * validation of the subcommands. Because earlier subcommands may change
4329 * the catalog state seen by later commands, there are limits to what can
4330 * be done in this phase. Generally, this phase acquires table locks,
4331 * checks permissions and relkind, and recurses to find child tables.
4332 *
4333 * ATRewriteCatalogs performs phase 2 for each affected table.
4334 * Certain subcommands need to be performed before others to avoid
4335 * unnecessary conflicts; for example, DROP COLUMN should come before
4336 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
4337 * lists, one for each logical "pass" of phase 2.
4338 *
4339 * ATRewriteTables performs phase 3 for those tables that need it.
4340 *
4341 * For most subcommand types, phases 2 and 3 do no explicit recursion,
4342 * since phase 1 already does it. However, for certain subcommand types
4343 * it is only possible to determine how to recurse at phase 2 time; for
4344 * those cases, phase 1 sets the cmd->recurse flag.
4345 *
4346 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
4347 * the whole operation; we don't have to do anything special to clean up.
4348 *
4349 * The caller must lock the relation, with an appropriate lock level
4350 * for the subcommands requested, using AlterTableGetLockLevel(stmt->cmds)
4351 * or higher. We pass the lock level down
4352 * so that we can apply it recursively to inherited tables. Note that the
4353 * lock level we want as we recurse might well be higher than required for
4354 * that specific subcommand. So we pass down the overall lock requirement,
4355 * rather than reassess it at lower levels.
4356 *
4357 * The caller also provides a "context" which is to be passed back to
4358 * utility.c when we need to execute a subcommand such as CREATE INDEX.
4359 * Some of the fields therein, such as the relid, are used here as well.
4360 */
4361 void
4364 {
4365 Relation rel;
4367 /* Caller is required to provide an adequate lock. */
4373 }
4375 /*
4376 * AlterTableInternal
4377 *
4378 * ALTER TABLE with target specified by OID
4379 *
4380 * We do not reject if the relation is already open, because it's quite
4381 * likely that one or more layers of caller have it open. That means it
4382 * is unsafe to use this entry point for alterations that could break
4383 * existing query plans. On the assumption it's not used for such, we
4384 * don't have to reject pending AFTER triggers, either.
4385 *
4386 * Also, since we don't have an AlterTableUtilityContext, this cannot be
4387 * used for any subcommand types that require parse transformation or
4388 * could generate subcommands that have to be passed to ProcessUtility.
4389 */
4390 void
4392 {
4393 Relation rel;
4401 }
4403 /*
4404 * AlterTableGetLockLevel
4405 *
4406 * Sets the overall lock level required for the supplied list of subcommands.
4407 * Policy for doing this set according to needs of AlterTable(), see
4408 * comments there for overall explanation.
4409 *
4410 * Function is called before and after parsing, so it must give same
4411 * answer each time it is called. Some subcommands are transformed
4412 * into other subcommand types, so the transform must never be made to a
4413 * lower lock level than previously assigned. All transforms are noted below.
4414 *
4415 * Since this is called before we lock the table we cannot use table metadata
4416 * to influence the type of lock we acquire.
4417 *
4418 * There should be no lockmodes hardcoded into the subcommand functions. All
4419 * lockmode decisions for ALTER TABLE are made here only. The one exception is
4420 * ALTER TABLE RENAME which is treated as a different statement type T_RenameStmt
4421 * and does not travel through this section of code and cannot be combined with
4422 * any of the subcommands given here.
4423 *
4424 * Note that Hot Standby only knows about AccessExclusiveLocks on the primary
4425 * so any changes that might affect SELECTs running on standbys need to use
4426 * AccessExclusiveLocks even if you think a lesser lock would do, unless you
4427 * have a solution for that also.
4428 *
4429 * Also note that pg_dump uses only an AccessShareLock, meaning that anything
4430 * that takes a lock less than AccessExclusiveLock can change object definitions
4431 * while pg_dump is running. Be careful to check that the appropriate data is
4432 * derived by pg_dump using an MVCC snapshot, rather than syscache lookups,
4433 * otherwise we might end up with an inconsistent dump that can't restore.
4434 */
4435 LOCKMODE
4437 {
4438 /*
4439 * This only works if we read catalog tables using MVCC snapshots.
4440 */
4445 {
4450 {
4451 /*
4452 * These subcommands rewrite the heap, so require full locks.
4453 */
4455 * to SELECT */
4462 /*
4463 * These subcommands may require addition of toast tables. If
4464 * we add a toast table to a table currently being scanned, we
4465 * might miss data added to the new toast table by concurrent
4466 * insert transactions.
4467 */
4469 * ATRewriteCatalogs() */
4473 /*
4474 * Removing constraints can affect SELECTs that have been
4475 * optimized assuming the constraint holds true. See also
4476 * CloneFkReferenced.
4477 */
4483 /*
4484 * Subcommands that may be visible to concurrent SELECTs
4485 */
4496 /*
4497 * Changing owner may remove implicit SELECT privileges
4498 */
4503 /*
4504 * Changing foreign table options may affect optimization.
4505 */
4511 /*
4512 * These subcommands affect write operations only.
4513 */
4525 /*
4526 * These subcommands affect write operations only. XXX
4527 * Theoretically, these could be ShareRowExclusiveLock.
4528 */
4553 {
4557 {
4562 /*
4563 * Cases essentially the same as CREATE INDEX. We
4564 * could reduce the lock strength to ShareLock if
4565 * we can work out how to allow concurrent catalog
4566 * updates. XXX Might be set down to
4567 * ShareRowExclusiveLock but requires further
4568 * analysis.
4569 */
4574 /*
4575 * We add triggers to both tables when we add a
4576 * Foreign Key, so the lock level must be at least
4577 * as strong as CREATE TRIGGER.
4578 */
4584 }
4585 }
4588 /*
4589 * These subcommands affect inheritance behaviour. Queries
4590 * started before us will continue to see the old inheritance
4591 * behaviour, while queries started after we commit will see
4592 * new behaviour. No need to prevent reads or writes to the
4593 * subtable while we hook it up though. Changing the TupDesc
4594 * may be a problem, so keep highest lock.
4595 */
4601 /*
4602 * These subcommands affect implicit row type conversion. They
4603 * have affects similar to CREATE/DROP CAST on queries. don't
4604 * provide for invalidating parse trees as a result of such
4605 * changes, so we keep these at AccessExclusiveLock.
4606 */
4612 /*
4613 * Only used by CREATE OR REPLACE VIEW which must conflict
4614 * with an SELECTs currently using the view.
4615 */
4620 /*
4621 * These subcommands affect general strategies for performance
4622 * and maintenance, though don't change the semantic results
4623 * from normal data reads and writes. Delaying an ALTER TABLE
4624 * behind currently active writes only delays the point where
4625 * the new strategy begins to take effect, so there is no
4626 * benefit in waiting. In this case the minimum restriction
4627 * applies: we don't currently allow concurrent catalog
4628 * updates.
4629 */
4647 /*
4648 * Rel options are more complex than first appears. Options
4649 * are set here for tables, views and indexes; for historical
4650 * reasons these can all be used with ALTER TABLE, so we can't
4651 * decide between them using the basic grammar.
4652 */
4654 * getTables() */
4656 * getTables() */
4667 else
4685 /*
4686 * This only examines the table's schema; but lock must be
4687 * strong enough to prevent concurrent DROP NOT NULL.
4688 */
4696 }
4698 /*
4699 * Take the greatest lockmode from any subcommand
4700 */
4703 }
4706 }
4708 /*
4709 * ATController provides top level control over the phases.
4710 *
4711 * parsetree is passed in to allow it to be passed to event triggers
4712 * when requested.
4713 */
4714 static void
4718 {
4722 /* Phase 1: preliminary examination of commands, create work queue */
4724 {
4728 }
4730 /* Close the relation, but keep lock until commit */
4733 /* Phase 2: update system catalogs */
4736 /* Phase 3: scan/rewrite tables as needed, and run afterStmts */
4738 }
4740 /*
4741 * ATPrepCmd
4742 *
4743 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
4744 * recursion and permission checks.
4745 *
4746 * Caller must have acquired appropriate lock type on relation already.
4747 * This lock should be held until commit.
4748 */
4749 static void
4753 {
4757 /* Find or create work queue entry for this table */
4760 /*
4761 * Disallow any ALTER TABLE other than ALTER TABLE DETACH FINALIZE on
4762 * partitions that are pending detach.
4763 */
4771 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
4773 /*
4774 * Copy the original subcommand for each table, so we can scribble on it.
4775 * This avoids conflicts when different child tables need to make
4776 * different parse transformations (for example, the same column may have
4777 * different column numbers in different children).
4778 */
4781 /*
4782 * Do permissions and relkind checking, recursion to child tables if
4783 * needed, and any additional phase-1 processing needed. (But beware of
4784 * adding any processing that looks at table details that another
4785 * subcommand could change. In some cases we reject multiple subcommands
4786 * that could try to change the same state in contrary ways.)
4787 */
4789 {
4795 /* Recursion occurs during execution phase */
4802 /* Recursion occurs during execution phase */
4807 /*
4808 * We allow defaults on views so that INSERT into a view can have
4809 * default-ish behavior. This works because the rewriter
4810 * substitutes default values into INSERTs before it expands
4811 * rules.
4812 */
4815 /* No command-specific prep needed */
4819 /* This is currently used only in CREATE TABLE */
4820 /* (so the permission check really isn't necessary) */
4822 /* This command never recurses */
4827 /* Set up recursion for phase 2; no other prep needed */
4834 /* Set up recursion for phase 2; no other prep needed */
4837 /* This should run after AddIdentity, so do it in MISC pass */
4842 /* Set up recursion for phase 2; no other prep needed */
4855 /* Need command-specific recursion decision */
4863 /* No command-specific prep needed */
4878 ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX | ATT_PARTITIONED_INDEX | ATT_FOREIGN_TABLE);
4880 /* No command-specific prep needed */
4886 /* This command never recurses */
4892 /* No command-specific prep needed */
4897 /* This command never recurses */
4898 /* No command-specific prep needed */
4906 /* Recursion occurs during execution phase */
4911 /* This command never recurses */
4912 /* No command-specific prep needed */
4917 /* Recursion occurs during execution phase */
4918 /* No command-specific prep needed except saving recurse flag */
4925 /* This command never recurses */
4926 /* No command-specific prep needed */
4932 /* Other recursion occurs during execution phase */
4933 /* No command-specific prep needed except saving recurse flag */
4941 /* See comments for ATPrepAlterColumnType */
4945 /* Performs own recursion */
4952 /* This command never recurses */
4953 /* No command-specific prep needed */
4957 /* This command never recurses */
4958 /* No command-specific prep needed */
4964 /* These commands never recurse */
4965 /* No command-specific prep needed */
4975 /* force rewrite if necessary; see comment in ATRewriteTables */
4977 {
4980 }
4990 /* force rewrite if necessary; see comment in ATRewriteTables */
4992 {
4995 }
5005 /* check if another access method change was already requested */
5016 ATT_PARTITIONED_INDEX);
5017 /* This command never recurses */
5025 /* This command never recurses */
5026 /* No command-specific prep needed */
5031 /* This command never recurses */
5037 /* This command never recurses */
5038 /* No command-specific prep needed */
5043 /* Recursion occurs during execution phase */
5048 /* Recursion occurs during execution phase */
5049 /* No command-specific prep needed except saving recurse flag */
5057 /* This command never recurses */
5058 /* No command-specific prep needed */
5069 /* Set up recursion for phase 2; no other prep needed */
5085 /* These commands never recurse */
5086 /* No command-specific prep needed */
5091 /* No command-specific prep needed */
5096 /* No command-specific prep needed */
5101 /* No command-specific prep needed */
5106 /* No command-specific prep needed */
5111 /* No command-specific prep needed */
5116 /* No command-specific prep needed */
5124 }
5127 /* Add the subcommand to the appropriate list for phase 2 */
5129 }
5131 /*
5132 * ATRewriteCatalogs
5133 *
5134 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
5135 * dispatched in a "safe" execution order (designed to avoid unnecessary
5136 * conflicts).
5137 */
5138 static void
5141 {
5144 /*
5145 * We process all the tables "in parallel", one pass at a time. This is
5146 * needed because we may have to propagate work from one table to another
5147 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
5148 * re-adding of the foreign key constraint to the other table). Work can
5149 * only be propagated into later passes, however.
5150 */
5152 {
5153 /* Go through each table that needs to be processed */
5155 {
5163 /*
5164 * Open the relation and store it in tab. This allows subroutines
5165 * close and reopen, if necessary. Appropriate lock was obtained
5166 * by phase 1, needn't get it again.
5167 */
5175 /*
5176 * After the ALTER TYPE or SET EXPRESSION pass, do cleanup work
5177 * (this is not done in ATExecAlterColumnType since it should be
5178 * done only once if multiple columns of a table are altered).
5179 */
5184 {
5187 }
5188 }
5189 }
5191 /* Check to see if a toast table must be added. */
5193 {
5196 /*
5197 * If the table is source table of ATTACH PARTITION command, we did
5198 * not modify anything about it that will change its toasting
5199 * requirement, so no need to check.
5200 */
5206 }
5207 }
5209 /*
5210 * ATExecCmd: dispatch a subcommand to appropriate execution routine
5211 */
5212 static void
5216 {
5221 {
5278 lockmode);
5284 NULL);
5288 lockmode);
5292 lockmode);
5299 /* Transform the command only during initial examination */
5304 /* Depending on constraint type, might be no more work to do now */
5306 address =
5312 address =
5317 * constraint */
5318 address =
5321 NULL);
5328 lockmode);
5343 /* parse transformation was done earlier */
5347 address =
5366 /* nothing to do here, oid columns don't exist anymore */
5370 /*
5371 * Only do this for partitioned tables, for which this is just a
5372 * catalog change. Tables with storage are handled by Phase 3.
5373 */
5380 /*
5381 * Only do this for partitioned tables and indexes, for which this
5382 * is just a catalog change. Other relation types which have
5383 * storage are handled by Phase 3.
5384 */
5399 lockmode);
5405 lockmode);
5411 lockmode);
5417 lockmode);
5423 lockmode);
5429 lockmode);
5435 lockmode);
5441 lockmode);
5497 context);
5498 else
5506 /* ATPrepCmd ensures it must be a table */
5521 context);
5529 context);
5535 }
5537 /*
5538 * Report the subcommand to interested event triggers.
5539 */
5543 /*
5544 * Bump the command counter to ensure the next subcommand in the sequence
5545 * can see the changes so far
5546 */
5548 }
5550 /*
5551 * ATParseTransformCmd: perform parse transformation for one subcommand
5552 *
5553 * Returns the transformed subcommand tree, if there is one, else NULL.
5554 *
5555 * The parser may hand back additional AlterTableCmd(s) and/or other
5556 * utility statements, either before or after the original subcommand.
5557 * Other AlterTableCmds are scheduled into the appropriate slot of the
5558 * AlteredTableInfo (they had better be for later passes than the current one).
5559 * Utility statements that are supposed to happen before the AlterTableCmd
5560 * are executed immediately. Those that are supposed to happen afterwards
5561 * are added to the tab->afterStmts list to be done at the very end.
5562 */
5567 {
5574 /* Gin up an AlterTableStmt with just this subcommand and this table */
5584 /* Transform the AlterTableStmt */
5586 atstmt,
5591 /* Execute any statements that should happen before these subcommand(s) */
5593 {
5598 }
5600 /* Examine the transformed subcommands and schedule them appropriately */
5602 {
5604 AlterTablePass pass;
5606 /*
5607 * This switch need only cover the subcommand types that can be added
5608 * by parse_utilcmd.c; otherwise, we'll use the default strategy of
5609 * executing the subcommand immediately, as a substitute for the
5610 * original subcommand. (Note, however, that this does cause
5611 * AT_AddConstraint subcommands to be rescheduled into later passes,
5612 * which is important for index and foreign key constraints.)
5613 *
5614 * We assume we needn't do any phase-1 checks for added subcommands.
5615 */
5617 {
5619 /* Need command-specific recursion decision */
5626 /* This command never recurses */
5627 /* No command-specific prep needed */
5631 /* This command never recurses */
5632 /* No command-specific prep needed */
5636 /* Recursion occurs during execution phase */
5640 {
5649 }
5652 /* This command never recurses */
5653 /* No command-specific prep needed */
5659 }
5662 {
5663 /* Cannot schedule into a pass we already finished */
5665 pass);
5666 }
5668 {
5669 /* OK, queue it up for later */
5671 }
5672 else
5673 {
5674 /*
5675 * We should see at most one subcommand for the current pass,
5676 * which is the transformed version of the original subcommand.
5677 */
5679 {
5680 /* Found the transformed version of our subcommand */
5682 }
5683 else
5685 pass);
5686 }
5687 }
5689 /* Queue up any after-statements to happen at the end */
5693 }
5695 /*
5696 * ATRewriteTables: ALTER TABLE phase 3
5697 */
5698 static void
5701 {
5704 /* Go through each table that needs to be checked or rewritten */
5706 {
5709 /* Relations without storage may be ignored here */
5713 /*
5714 * If we change column data types, the operation has to be propagated
5715 * to tables that use this table's rowtype as a column type.
5716 * tab->newvals will also be non-NULL in the case where we're adding a
5717 * column with a default. We choose to forbid that case as well,
5718 * since composite types might eventually support defaults.
5719 *
5720 * (Eventually we'll probably need to check for composite type
5721 * dependencies even when we're just scanning the table without a
5722 * rewrite, but at the moment a composite type does not enforce any
5723 * constraints, so it's not necessary/appropriate to enforce them just
5724 * during ALTER.)
5725 */
5727 {
5728 Relation rel;
5733 }
5735 /*
5736 * We only need to rewrite the table if at least one column needs to
5737 * be recomputed, or we are changing its persistence or access method.
5738 *
5739 * There are two reasons for requiring a rewrite when changing
5740 * persistence: on one hand, we need to ensure that the buffers
5741 * belonging to each of the two relations are marked with or without
5742 * BM_PERMANENT properly. On the other hand, since rewriting creates
5743 * and assigns a new relfilenumber, we automatically create or drop an
5744 * init fork for the relation as appropriate.
5745 */
5747 {
5748 /* Build a temporary relation and copy data */
5749 Relation OldHeap;
5750 Oid OIDNewHeap;
5751 Oid NewAccessMethod;
5752 Oid NewTableSpace;
5757 /*
5758 * We don't support rewriting of system catalogs; there are too
5759 * many corner cases and too little benefit. In particular this
5760 * is certainly not going to work for mapped catalogs.
5761 */
5774 /*
5775 * Don't allow rewrite on temp tables of other backends ... their
5776 * local buffer manager is not going to cope. (This is redundant
5777 * with the check in CheckAlterTableIsSafe, but for safety we'll
5778 * check here too.)
5779 */
5785 /*
5786 * Select destination tablespace (same as original unless user
5787 * requested a change)
5788 */
5791 else
5794 /*
5795 * Select destination access method (same as original unless user
5796 * requested a change)
5797 */
5800 else
5803 /*
5804 * Select persistence of transient table (same as original unless
5805 * user requested a change)
5806 */
5812 /*
5813 * Fire off an Event Trigger now, before actually rewriting the
5814 * table.
5815 *
5816 * We don't support Event Trigger for nested commands anywhere,
5817 * here included, and parsetree is given NULL when coming from
5818 * AlterTableInternal.
5819 *
5820 * And fire it only once.
5821 */
5827 /*
5828 * Create transient table that will receive the modified data.
5829 *
5830 * Ensure it is marked correctly as logged or unlogged. We have
5831 * to do this here so that buffers for the new relfilenumber will
5832 * have the right persistence set, and at the same time ensure
5833 * that the original filenumbers's buffers will get read in with
5834 * the correct setting (i.e. the original one). Otherwise a
5835 * rollback after the rewrite would possibly result with buffers
5836 * for the original filenumbers having the wrong persistence
5837 * setting.
5838 *
5839 * NB: This relies on swap_relation_files() also swapping the
5840 * persistence. That wouldn't work for pg_class, but that can't be
5841 * unlogged anyway.
5842 */
5846 /*
5847 * Copy the heap data into the new table with the desired
5848 * modifications, and test the current data within the table
5849 * against new constraints generated by ALTER TABLE commands.
5850 */
5853 /*
5854 * Swap the physical files of the old and new heaps, then rebuild
5855 * indexes and discard the old heap. We can use RecentXmin for
5856 * the table's new relfrozenxid because we rewrote all the tuples
5857 * in ATRewriteTable, so no older Xid remains in the table. Also,
5858 * we never try to swap toast tables by content, since we have no
5859 * interest in letting this code work on system catalogs.
5860 */
5864 RecentXmin,
5866 persistence);
5869 }
5871 {
5874 }
5875 else
5876 {
5877 /*
5878 * If required, test the current data within the table against new
5879 * constraints generated by ALTER TABLE commands, but don't
5880 * rebuild data.
5881 */
5886 /*
5887 * If we had SET TABLESPACE but no reason to reconstruct tuples,
5888 * just do a block-by-block copy.
5889 */
5892 }
5894 /*
5895 * Also change persistence of owned sequences, so that it matches the
5896 * table persistence.
5897 */
5899 {
5904 {
5908 }
5909 }
5910 }
5912 /*
5913 * Foreign key constraints are checked in a final pass, since (a) it's
5914 * generally best to examine each one separately, and (b) it's at least
5915 * theoretically possible that we have changed both relations of the
5916 * foreign key, and we'd better have finished both rewrites before we try
5917 * to read the tables.
5918 */
5920 {
5925 /* Relations without storage may be ignored here too */
5930 {
5934 {
5936 Relation refrel;
5939 {
5940 /* Long since locked, no need for another */
5942 }
5950 /*
5951 * No need to mark the constraint row as validated, we did
5952 * that when we inserted the row earlier.
5953 */
5956 }
5957 }
5961 }
5963 /* Finally, run any afterStmts that were queued up */
5965 {
5970 {
5975 }
5976 }
5977 }
5979 /*
5980 * ATRewriteTable: scan or rewrite one table
5981 *
5982 * OIDNewHeap is InvalidOid if we don't need to rewrite
5983 */
5984 static void
5986 {
5987 Relation oldrel;
5988 Relation newrel;
5989 TupleDesc oldTupDesc;
5990 TupleDesc newTupDesc;
5996 CommandId mycid;
5997 BulkInsertState bistate;
6001 /*
6002 * Open the relation(s). We have surely already locked the existing
6003 * table.
6004 */
6011 else
6014 /*
6015 * Prepare a BulkInsertState and options for table_tuple_insert. The FSM
6016 * is empty, so don't bother using it.
6017 */
6019 {
6023 }
6024 else
6025 {
6026 /* keep compiler quiet about using these uninitialized */
6030 }
6032 /*
6033 * Generate the constraint and default execution states
6034 */
6038 /* Build the needed expression execution states */
6040 {
6044 {
6050 /* Nothing to do here */
6055 }
6056 }
6058 /* Build expression execution states for partition check quals */
6060 {
6063 }
6066 {
6069 /* expr already planned */
6071 }
6075 {
6076 /*
6077 * If we are rebuilding the tuples OR if we added any new but not
6078 * verified not-null constraints, check all not-null constraints. This
6079 * is a bit of overkill but it minimizes risk of bugs, and
6080 * heap_attisnull is a pretty cheap test anyway.
6081 */
6083 {
6088 }
6091 }
6094 {
6098 TableScanDesc scan;
6099 MemoryContext oldCxt;
6102 Snapshot snapshot;
6108 else
6114 {
6115 /*
6116 * All predicate locks on the tuples or pages are about to be made
6117 * invalid, because we move tuples around. Promote them to
6118 * relation locks.
6119 */
6121 }
6125 /*
6126 * Create necessary tuple slots. When rewriting, two slots are needed,
6127 * otherwise one suffices. In the case where one slot suffices, we
6128 * need to use the new tuple descriptor, otherwise some constraints
6129 * can't be evaluated. Note that even when the tuple layout is the
6130 * same and no rewrite is required, the tupDescs might not be
6131 * (consider ADD COLUMN without a default).
6132 */
6134 {
6141 /*
6142 * Set all columns in the new slot to NULL initially, to ensure
6143 * columns added as part of the rewrite are initialized to NULL.
6144 * That is necessary as tab->newvals will not contain an
6145 * expression for columns with a NULL default, e.g. when adding a
6146 * column without a default together with a column with a default
6147 * requiring an actual rewrite.
6148 */
6150 }
6151 else
6152 {
6156 }
6158 /*
6159 * Any attributes that are dropped according to the new tuple
6160 * descriptor can be set to NULL. We precompute the list of dropped
6161 * attributes to avoid needing to do so in the per-tuple loop.
6162 */
6164 {
6167 }
6169 /*
6170 * Scan through the rows, generating a new row if needed and then
6171 * checking all the constraints.
6172 */
6176 /*
6177 * Switch to per-tuple memory context and reset it for each tuple
6178 * produced, so we don't leak memory.
6179 */
6183 {
6187 {
6188 /* Extract data from old tuple */
6192 /* copy attributes */
6198 /* Set dropped attributes to null in new tuple */
6202 /*
6203 * Constraints and GENERATED expressions might reference the
6204 * tableoid column, so fill tts_tableOid with the desired
6205 * value. (We must do this each time, because it gets
6206 * overwritten with newrel's OID during storing.)
6207 */
6210 /*
6211 * Process supplied expressions to replace selected columns.
6212 *
6213 * First, evaluate expressions whose inputs come from the old
6214 * tuple.
6215 */
6219 {
6227 econtext,
6229 }
6233 /*
6234 * Now, evaluate any expressions whose inputs come from the
6235 * new tuple. We assume these columns won't reference each
6236 * other, so that there's no ordering dependency.
6237 */
6241 {
6249 econtext,
6251 }
6254 }
6255 else
6256 {
6257 /*
6258 * If there's no rewrite, old and new table are guaranteed to
6259 * have the same AM, so we can just use the old slot to verify
6260 * new constraints etc.
6261 */
6263 }
6265 /* Now check any constraints on the possibly-changed tuple */
6269 {
6273 {
6282 }
6283 }
6286 {
6290 {
6301 /* Nothing to do here */
6306 }
6307 }
6310 {
6314 errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
6317 else
6323 }
6325 /* Write the tuple out to the new relation */
6333 }
6342 }
6348 {
6354 }
6355 }
6357 /*
6358 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
6359 */
6362 {
6368 {
6372 }
6374 /*
6375 * Not there, so add it. Note that we make a copy of the relation's
6376 * existing descriptor before anything interesting can happen to it.
6377 */
6392 }
6396 {
6398 {
6531 }
6534 }
6536 /*
6537 * ATSimplePermissions
6538 *
6539 * - Ensure that it is a relation (or possibly a view)
6540 * - Ensure this user is the owner
6541 * - Ensure that it is not a system table
6542 */
6543 static void
6545 {
6549 {
6578 }
6580 /* Wrong target type? */
6582 {
6588 /* translator: %s is a group of some SQL keywords */
6592 else
6593 /* internal error? */
6596 }
6598 /* Permissions checks */
6608 }
6610 /*
6611 * ATSimpleRecursion
6612 *
6613 * Simple table recursion sufficient for most ALTER TABLE operations.
6614 * All direct and indirect children are processed in an unspecified order.
6615 * Note that if a child inherits from the original table via multiple
6616 * inheritance paths, it will be visited just once.
6617 */
6618 static void
6622 {
6623 /*
6624 * Propagate to children, if desired and if there are (or might be) any
6625 * children.
6626 */
6628 {
6635 /*
6636 * find_all_inheritors does the recursive search of the inheritance
6637 * hierarchy, so all we have to do is process all of the relids in the
6638 * list that it returns.
6639 */
6641 {
6643 Relation childrel;
6647 /* find_all_inheritors already got lock */
6652 }
6653 }
6654 }
6656 /*
6657 * Obtain list of partitions of the given table, locking them all at the given
6658 * lockmode and ensuring that they all pass CheckAlterTableIsSafe.
6659 *
6660 * This function is a no-op if the given relation is not a partitioned table;
6661 * in particular, nothing is done if it's a legacy inheritance parent.
6662 */
6663 static void
6665 {
6667 {
6672 /* first element is the parent rel; must ignore it */
6674 {
6675 Relation childrel;
6677 /* find_all_inheritors already got lock */
6681 }
6683 }
6684 }
6686 /*
6687 * ATTypedTableRecursion
6688 *
6689 * Propagate ALTER TYPE operations to the typed tables of that type.
6690 * Also check the RESTRICT/CASCADE behavior. Given CASCADE, also permit
6691 * recursion to inheritance children of the typed tables.
6692 */
6693 static void
6696 {
6707 {
6709 Relation childrel;
6715 }
6716 }
6719 /*
6720 * find_composite_type_dependencies
6721 *
6722 * Check to see if the type "typeOid" is being used as a column in some table
6723 * (possibly nested several levels deep in composite types, arrays, etc!).
6724 * Eventually, we'd like to propagate the check or rewrite operation
6725 * into such tables, but for now, just error out if we find any.
6726 *
6727 * Caller should provide either the associated relation of a rowtype,
6728 * or a type name (not both) for use in the error message, if any.
6729 *
6730 * Note that "typeOid" is not necessarily a composite type; it could also be
6731 * another container type such as an array or range, or a domain over one of
6732 * these things. The name of this function is therefore somewhat historical,
6733 * but it's not worth changing.
6734 *
6735 * We assume that functions and views depending on the type are not reasons
6736 * to reject the ALTER. (How safe is this really?)
6737 */
6738 void
6741 {
6742 Relation depRel;
6744 SysScanDesc depScan;
6745 HeapTuple depTup;
6747 /* since this function recurses, it could be driven to stack overflow */
6750 /*
6751 * We scan pg_depend to find those things that depend on the given type.
6752 * (We assume we can ignore refobjsubid for a type.)
6753 */
6757 Anum_pg_depend_refclassid,
6761 Anum_pg_depend_refobjid,
6769 {
6771 Relation rel;
6772 TupleDesc tupleDesc;
6773 Form_pg_attribute att;
6775 /* Check for directly dependent types */
6777 {
6778 /*
6779 * This must be an array, domain, or range containing the given
6780 * type, so recursively check for uses of this type. Note that
6781 * any error message will mention the original type not the
6782 * container; this is intentional.
6783 */
6787 }
6789 /* Else, ignore dependees that aren't relations */
6796 /*
6797 * If objsubid identifies a specific column, refer to that in error
6798 * messages. Otherwise, search to see if there's a user column of the
6799 * type. (We assume system columns are never of interesting types.)
6800 * The search is needed because an index containing an expression
6801 * column of the target type will just be recorded as a whole-relation
6802 * dependency. If we do not find a column of the type, the dependency
6803 * must indicate that the type is transiently referenced in an index
6804 * expression but not stored on disk, which we assume is OK, just as
6805 * we do for references in views. (It could also be that the target
6806 * type is embedded in some container type that is stored in an index
6807 * column, but the previous recursion should catch such cases.)
6808 */
6811 else
6812 {
6815 {
6820 }
6822 {
6823 /* No such column, so assume OK */
6826 }
6827 }
6829 /*
6830 * We definitely should reject if the relation has storage. If it's
6831 * partitioned, then perhaps we don't have to reject: if there are
6832 * partitions then we'll fail when we find one, else there is no
6833 * stored data to worry about. However, it's possible that the type
6834 * change would affect conclusions about whether the type is sortable
6835 * or hashable and thus (if it's a partitioning column) break the
6836 * partitioning rule. For now, reject for partitioned rels too.
6837 */
6840 {
6845 origTypeName,
6862 else
6869 }
6871 {
6872 /*
6873 * A view or composite type itself isn't a problem, but we must
6874 * recursively check for indirect dependencies via its rowtype.
6875 */
6878 }
6881 }
6886 }
6889 /*
6890 * find_typed_table_dependencies
6891 *
6892 * Check to see if a composite type is being used as the type of a
6893 * typed table. Abort if any are found and behavior is RESTRICT.
6894 * Else return the list of tables.
6895 */
6898 {
6899 Relation classRel;
6901 TableScanDesc scan;
6902 HeapTuple tuple;
6908 Anum_pg_class_reloftype,
6915 {
6922 typeName),
6924 else
6926 }
6932 }
6935 /*
6936 * check_of_type
6937 *
6938 * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF. If it
6939 * isn't suitable, throw an error. Currently, we require that the type
6940 * originated with CREATE TYPE AS. We could support any row type, but doing so
6941 * would require handling a number of extra corner cases in the DDL commands.
6942 * (Also, allowing domain-over-composite would open up a can of worms about
6943 * whether and how the domain's constraints should apply to derived tables.)
6944 */
6945 void
6947 {
6952 {
6953 Relation typeRelation;
6959 /*
6960 * Close the parent rel, but keep our AccessShareLock on it until xact
6961 * commit. That will prevent someone else from deleting or ALTERing
6962 * the type before the typed table creation/conversion commits.
6963 */
6965 }
6971 }
6974 /*
6975 * ALTER TABLE ADD COLUMN
6976 *
6977 * Adds an additional attribute to a relation making the assumption that
6978 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
6979 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
6980 * AlterTableCmd's.
6981 *
6982 * ADD COLUMN cannot use the normal ALTER TABLE recursion mechanism, because we
6983 * have to decide at runtime whether to recurse or not depending on whether we
6984 * actually add a column or merely merge with an existing column. (We can't
6985 * check this in a static pre-pass because it won't handle multiple inheritance
6986 * situations correctly.)
6987 */
6988 static void
6992 {
7003 }
7005 /*
7006 * Add a column to a table. The return value is the address of the
7007 * new column in the parent relation.
7008 *
7009 * cmd is pass-by-ref so that we can replace it with the parse-transformed
7010 * copy (but that happens only after we check for IF NOT EXISTS).
7011 */
7012 static ObjectAddress
7017 {
7021 Relation pgclass,
7022 attrdesc;
7023 HeapTuple reltup;
7024 Form_pg_attribute attribute;
7031 ObjectAddress address;
7032 TupleDesc tupdesc;
7034 /* since this function recurses, it could be driven to stack overflow */
7037 /* At top level, permission check was done in ATPrepCmd, else do it */
7048 /*
7049 * Are we adding the column to a recursion child? If so, check whether to
7050 * merge with an existing definition for the column. If we do merge, we
7051 * must not recurse. Children will already have the column, and recursing
7052 * into them would mess up attinhcount.
7053 */
7055 {
7056 HeapTuple tuple;
7058 /* Does child already have a column by this name? */
7061 {
7063 Oid ctypeId;
7064 int32 ctypmod;
7065 Oid ccollid;
7067 /* Child column must match on type, typmod, and collation */
7085 /* Bump the existing child att's inhcount */
7095 /* Inform the user about the merge */
7102 /* Make the child column change visible */
7106 }
7107 }
7109 /* skip if the name already exists and if_not_exists is true */
7111 {
7114 }
7116 /*
7117 * Okay, we need to add the column, so go ahead and do parse
7118 * transformation. This can result in queueing up, or even immediately
7119 * executing, subsidiary operations (such as creation of unique indexes);
7120 * so we mustn't do it until we have made the if_not_exists check.
7121 *
7122 * When recursing, the command was already transformed and we needn't do
7123 * so again. Also, if context isn't given we can't transform. (That
7124 * currently happens only for AT_AddColumnToView; we expect that view.c
7125 * passed us a ColumnDef that doesn't need work.)
7126 */
7128 {
7133 }
7135 /*
7136 * Regular inheritance children are independent enough not to inherit the
7137 * identity column from parent hence cannot recursively add identity
7138 * column if the table has inheritance children.
7139 *
7140 * Partitions, on the other hand, are integral part of a partitioned table
7141 * and inherit identity column. Hence propagate identity column down the
7142 * partition hierarchy.
7143 */
7145 recurse &&
7159 /* Determine the new attribute's number */
7165 MaxHeapAttributeNumber)));
7167 /*
7168 * Construct new attribute's pg_attribute entry.
7169 */
7174 /* Fix up attribute number */
7177 /* make sure datatype is legal for a column */
7186 /*
7187 * Update pg_class tuple as appropriate
7188 */
7195 /* Post creation hook for new attribute */
7200 /* Make the attribute's catalog entry visible */
7203 /*
7204 * Store the DEFAULT, if any, in the catalogs
7205 */
7207 {
7214 /*
7215 * Attempt to skip a complete table rewrite by storing the specified
7216 * DEFAULT value outside of the heap. This may be disabled inside
7217 * AddRelationNewConstraints if the optimization cannot be applied.
7218 */
7223 /*
7224 * This function is intended for CREATE TABLE, so it processes a
7225 * _list_ of defaults, but we just do one.
7226 */
7230 /* Make the additional catalog changes visible */
7233 /*
7234 * Did the request for a missing value work? If not we'll have to do a
7235 * rewrite
7236 */
7239 }
7241 /*
7242 * Tell Phase 3 to fill in the default expression, if there is one.
7243 *
7244 * If there is no default, Phase 3 doesn't have to do anything, because
7245 * that effectively means that the default is NULL. The heap tuple access
7246 * routines always check for attnum > # of attributes in tuple, and return
7247 * NULL if so, so without any modification of the tuple data we will get
7248 * the effect of NULL values in the new column.
7249 *
7250 * An exception occurs when the new column is of a domain type: the domain
7251 * might have a not-null constraint, or a check constraint that indirectly
7252 * rejects nulls. If there are any domain constraints then we construct
7253 * an explicit NULL default value that will be passed through
7254 * CoerceToDomain processing. (This is a tad inefficient, since it causes
7255 * rewriting the table which we really don't have to do, but the present
7256 * design of domain processing doesn't offer any simple way of checking
7257 * the constraints more directly.)
7258 *
7259 * Note: we use build_column_default, and not just the cooked default
7260 * returned by AddRelationNewConstraints, so that the right thing happens
7261 * when a datatype's default applies.
7262 *
7263 * Note: it might seem that this should happen at the end of Phase 2, so
7264 * that the effects of subsequent subcommands can be taken into account.
7265 * It's intentional that we do it now, though. The new column should be
7266 * filled according to what is said in the ADD COLUMN subcommand, so that
7267 * the effects are the same as if this subcommand had been run by itself
7268 * and the later subcommands had been issued in new ALTER TABLE commands.
7269 *
7270 * We can skip this entirely for relations without storage, since Phase 3
7271 * is certainly not going to touch them. System attributes don't have
7272 * interesting defaults, either.
7273 */
7275 {
7276 /*
7277 * For an identity column, we can't use build_column_default(),
7278 * because the sequence ownership isn't set yet. So do it manually.
7279 */
7281 {
7289 /* must do a rewrite for identity columns */
7291 }
7292 else
7296 {
7297 Oid baseTypeId;
7298 int32 baseTypeMod;
7299 Oid baseTypeColl;
7307 baseTypeId,
7310 COERCION_ASSIGNMENT,
7311 COERCE_IMPLICIT_CAST,
7315 }
7318 {
7327 }
7333 {
7334 /*
7335 * If the new column is NOT NULL, and there is no missing value,
7336 * tell Phase 3 it needs to check for NULLs.
7337 */
7339 }
7340 }
7342 /*
7343 * Add needed dependency entries for the new column.
7344 */
7348 /*
7349 * Propagate to children as appropriate. Unlike most other ALTER
7350 * routines, we have to do this one level of recursion at a time; we can't
7351 * use find_all_inheritors to do it in one pass.
7352 */
7353 children =
7356 /*
7357 * If we are told not to recurse, there had better not be any child
7358 * tables; else the addition would put them out of step.
7359 */
7365 /* Children should see column as singly inherited */
7367 {
7372 }
7373 else
7377 {
7379 Relation childrel;
7382 /* find_inheritance_children already got lock */
7386 /* Find or create work queue entry for this table */
7389 /* Recurse to child; return value is ignored */
7395 }
7399 }
7401 /*
7402 * If a new or renamed column will collide with the name of an existing
7403 * column and if_not_exists is false then error out, else do nothing.
7404 */
7405 static bool
7408 {
7409 HeapTuple attTuple;
7412 /*
7413 * this test is deliberately not attisdropped-aware, since if one tries to
7414 * add a column matching a dropped column name, it's gonna fail anyway.
7415 */
7425 /*
7426 * We throw a different error message for conflicts with system column
7427 * names, since they are normally not shown and the user might otherwise
7428 * be confused about the reason for the conflict.
7429 */
7434 colname)));
7435 else
7436 {
7438 {
7444 }
7450 }
7453 }
7455 /*
7456 * Install a column's dependency on its datatype.
7457 */
7458 static void
7460 {
7461 ObjectAddress myself,
7462 referenced;
7471 }
7473 /*
7474 * Install a column's dependency on its collation.
7475 */
7476 static void
7478 {
7479 ObjectAddress myself,
7480 referenced;
7482 /* We know the default collation is pinned, so don't bother recording it */
7484 {
7492 }
7493 }
7495 /*
7496 * ALTER TABLE ALTER COLUMN DROP NOT NULL
7497 */
7499 static void
7501 {
7502 /*
7503 * If the parent is a partitioned table, like check constraints, we do not
7504 * support removing the NOT NULL while partitions exist.
7505 */
7507 {
7516 }
7517 }
7519 /*
7520 * Return the address of the modified column. If the column was already
7521 * nullable, InvalidObjectAddress is returned.
7522 */
7523 static ObjectAddress
7525 {
7526 HeapTuple tuple;
7527 Form_pg_attribute attTup;
7528 AttrNumber attnum;
7529 Relation attr_rel;
7531 ObjectAddress address;
7533 /*
7534 * lookup the attribute
7535 */
7547 /* Prevent them from altering a system attribute */
7552 colName)));
7560 /*
7561 * Check that the attribute is not in a primary key or in an index used as
7562 * a replica identity.
7563 *
7564 * Note: we'll throw error even if the pkey index is not valid.
7565 */
7567 /* Loop over all indexes on the relation */
7571 {
7572 HeapTuple indexTuple;
7573 Form_pg_index indexStruct;
7580 /*
7581 * If the index is not a primary key or an index used as replica
7582 * identity, skip the check.
7583 */
7585 {
7586 /*
7587 * Loop over each attribute in the primary key or the index used
7588 * as replica identity and see if it matches the to-be-altered
7589 * attribute.
7590 */
7592 {
7594 {
7599 colName)));
7600 else
7604 colName)));
7605 }
7606 }
7607 }
7610 }
7614 /* If rel is partition, shouldn't drop NOT NULL if parent has the same */
7616 {
7620 AttrNumber parent_attnum;
7627 colName)));
7629 }
7631 /*
7632 * Okay, actually perform the catalog change ... if needed
7633 */
7635 {
7642 }
7643 else
7652 }
7654 /*
7655 * ALTER TABLE ALTER COLUMN SET NOT NULL
7656 */
7658 static void
7662 {
7663 /*
7664 * If we're already recursing, there's nothing to do; the topmost
7665 * invocation of ATSimpleRecursion already visited all children.
7666 */
7670 /*
7671 * If the target column is already marked NOT NULL, we can skip recursing
7672 * to children, because their columns should already be marked NOT NULL as
7673 * well. But there's no point in checking here unless the relation has
7674 * some children; else we can just wait till execution to check. (If it
7675 * does have children, however, this can save taking per-child locks
7676 * unnecessarily. This greatly improves concurrency in some parallel
7677 * restore scenarios.)
7678 *
7679 * Unfortunately, we can only apply this optimization to partitioned
7680 * tables, because traditional inheritance doesn't enforce that child
7681 * columns be NOT NULL when their parent is. (That's a bug that should
7682 * get fixed someday.)
7683 */
7686 {
7687 HeapTuple tuple;
7692 /* Might as well throw the error now, if name is bad */
7703 }
7705 /*
7706 * If we have ALTER TABLE ONLY ... SET NOT NULL on a partitioned table,
7707 * apply ALTER TABLE ... CHECK NOT NULL to every child. Otherwise, use
7708 * normal recursion logic.
7709 */
7712 {
7718 }
7719 else
7721 }
7723 /*
7724 * Return the address of the modified column. If the column was already NOT
7725 * NULL, InvalidObjectAddress is returned.
7726 */
7727 static ObjectAddress
7730 {
7731 HeapTuple tuple;
7732 AttrNumber attnum;
7733 Relation attr_rel;
7734 ObjectAddress address;
7736 /*
7737 * lookup the attribute
7738 */
7751 /* Prevent them from altering a system attribute */
7756 colName)));
7758 /*
7759 * Okay, actually perform the catalog change ... if needed
7760 */
7762 {
7767 /*
7768 * Ordinarily phase 3 must ensure that no NULLs exist in columns that
7769 * are set NOT NULL; however, if we can find a constraint which proves
7770 * this then we can skip that. We needn't bother looking if we've
7771 * already found that we must verify some other not-null constraint.
7772 */
7775 {
7776 /* Tell Phase 3 it needs to test the constraint */
7778 }
7782 }
7783 else
7792 }
7794 /*
7795 * ALTER TABLE ALTER COLUMN CHECK NOT NULL
7796 *
7797 * This doesn't exist in the grammar, but we generate AT_CheckNotNull
7798 * commands against the partitions of a partitioned table if the user
7799 * writes ALTER TABLE ONLY ... SET NOT NULL on the partitioned table,
7800 * or tries to create a primary key on it (which internally creates
7801 * AT_SetNotNull on the partitioned table). Such a command doesn't
7802 * allow us to actually modify any partition, but we want to let it
7803 * go through if the partitions are already properly marked.
7804 *
7805 * In future, this might need to adjust the child table's state, likely
7806 * by incrementing an inheritance count for the attnotnull constraint.
7807 * For now we need only check for the presence of the flag.
7808 */
7809 static void
7812 {
7813 HeapTuple tuple;
7832 }
7834 /*
7835 * NotNullImpliedByRelConstraints
7836 * Does rel's existing constraints imply NOT NULL for the given attribute?
7837 */
7838 static bool
7840 {
7851 /*
7852 * argisrow = false is correct even for a composite column, because
7853 * attnotnull does not represent a SQL-spec IS NOT NULL test in such a
7854 * case, just IS DISTINCT FROM NULL.
7855 */
7860 {
7862 (errmsg_internal("existing constraints on column \"%s.%s\" are sufficient to prove that it does not contain nulls",
7865 }
7868 }
7870 /*
7871 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
7872 *
7873 * Return the address of the affected column.
7874 */
7875 static ObjectAddress
7878 {
7880 AttrNumber attnum;
7881 ObjectAddress address;
7883 /*
7884 * get the number of the attribute
7885 */
7893 /* Prevent them from altering a system attribute */
7898 colName)));
7905 /* translator: %s is an SQL ALTER command */
7914 newDefault ?
7915 /* translator: %s is an SQL ALTER command */
7920 /*
7921 * Remove any old default for the column. We use RESTRICT here for
7922 * safety, but at present we do not expect anything to depend on the
7923 * default.
7924 *
7925 * We treat removing the existing default as an internal operation when it
7926 * is preparatory to adding a new default, but as a user-initiated
7927 * operation when the user asked for a drop.
7928 */
7933 {
7934 /* SET DEFAULT */
7943 /*
7944 * This function is intended for CREATE TABLE, so it processes a
7945 * _list_ of defaults, but we just do one.
7946 */
7949 }
7954 }
7956 /*
7957 * Add a pre-cooked default expression.
7958 *
7959 * Return the address of the affected column.
7960 */
7961 static ObjectAddress
7964 {
7965 ObjectAddress address;
7967 /* We assume no checking is required */
7969 /*
7970 * Remove any old default for the column. We use RESTRICT here for
7971 * safety, but at present we do not expect anything to depend on the
7972 * default. (In ordinary cases, there could not be a default in place
7973 * anyway, but it's possible when combining LIKE with inheritance.)
7974 */
7983 }
7985 /*
7986 * ALTER TABLE ALTER COLUMN ADD IDENTITY
7987 *
7988 * Return the address of the affected column.
7989 */
7990 static ObjectAddress
7993 {
7994 Relation attrelation;
7995 HeapTuple tuple;
7996 Form_pg_attribute attTup;
7997 AttrNumber attnum;
7998 ObjectAddress address;
8025 /* Can't alter a system attribute */
8030 colName)));
8032 /*
8033 * Creating a column as identity implies NOT NULL, so adding the identity
8034 * to an existing column that is not NOT NULL would create a state that
8035 * cannot be reproduced without contortions.
8036 */
8040 errmsg("column \"%s\" of relation \"%s\" must be declared NOT NULL before identity can be added",
8067 /*
8068 * Recurse to propagate the identity column to partitions. Identity is
8069 * not inherited in regular inheritance children.
8070 */
8072 {
8079 {
8080 Relation childrel;
8085 }
8086 }
8089 }
8091 /*
8092 * ALTER TABLE ALTER COLUMN SET { GENERATED or sequence options }
8093 *
8094 * Return the address of the affected column.
8095 */
8096 static ObjectAddress
8099 {
8102 HeapTuple tuple;
8103 Form_pg_attribute attTup;
8104 AttrNumber attnum;
8105 Relation attrelation;
8106 ObjectAddress address;
8122 {
8126 {
8132 }
8133 else
8136 }
8138 /*
8139 * Even if there is nothing to change here, we run all the checks. There
8140 * will be a subsequent ALTER SEQUENCE that relies on everything being
8141 * there.
8142 */
8159 colName)));
8168 {
8177 }
8178 else
8184 /*
8185 * Recurse to propagate the identity change to partitions. Identity is not
8186 * inherited in regular inheritance children.
8187 */
8189 {
8196 {
8197 Relation childrel;
8202 }
8203 }
8206 }
8208 /*
8209 * ALTER TABLE ALTER COLUMN DROP IDENTITY
8210 *
8211 * Return the address of the affected column.
8212 */
8213 static ObjectAddress
8216 {
8217 HeapTuple tuple;
8218 Form_pg_attribute attTup;
8219 AttrNumber attnum;
8220 Relation attrelation;
8221 ObjectAddress address;
8222 Oid seqid;
8223 ObjectAddress seqaddress;
8253 colName)));
8256 {
8262 else
8263 {
8270 }
8271 }
8285 /*
8286 * Recurse to drop the identity from column in partitions. Identity is
8287 * not inherited in regular inheritance children so ignore them.
8288 */
8290 {
8297 {
8298 Relation childrel;
8303 }
8304 }
8307 {
8308 /* drop the internal sequence */
8317 }
8320 }
8322 /*
8323 * ALTER TABLE ALTER COLUMN SET EXPRESSION
8324 *
8325 * Return the address of the affected column.
8326 */
8327 static ObjectAddress
8330 {
8331 HeapTuple tuple;
8332 Form_pg_attribute attTup;
8333 AttrNumber attnum;
8334 Oid attrdefoid;
8335 ObjectAddress address;
8354 colName)));
8363 /*
8364 * Clear all the missing values if we're rewriting the table, since this
8365 * renders them pointless.
8366 */
8369 /* make sure we don't conflict with later attribute modifications */
8372 /*
8373 * Find everything that depends on the column (constraints, indexes, etc),
8374 * and record enough information to let us recreate the objects after
8375 * rewrite.
8376 */
8379 /*
8380 * Drop the dependency records of the GENERATED expression, in particular
8381 * its INTERNAL dependency on the column, which would otherwise cause
8382 * dependency.c to refuse to perform the deletion.
8383 */
8390 /* Make above changes visible */
8393 /*
8394 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8395 * safety, but at present we do not expect anything to depend on the
8396 * expression.
8397 */
8401 /* Prepare to store the new expression, in the catalogs */
8408 /* Store the generated expression */
8412 /* Make above new expression visible */
8415 /* Prepare for table rewrite */
8426 /* Drop any pg_statistic entry for the column */
8435 }
8437 /*
8438 * ALTER TABLE ALTER COLUMN DROP EXPRESSION
8439 */
8440 static void
8441 ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
8442 {
8443 /*
8444 * Reject ONLY if there are child tables. We could implement this, but it
8445 * is a bit complicated. GENERATED clauses must be attached to the column
8446 * definition and cannot be added later like DEFAULT, so if a child table
8447 * has a generation expression that the parent does not have, the child
8448 * column will necessarily be an attislocal column. So to implement ONLY
8449 * here, we'd need extra code to update attislocal of the direct child
8450 * tables, somewhat similar to how DROP COLUMN does it, so that the
8451 * resulting state can be properly dumped and restored.
8452 */
8459 /*
8460 * Cannot drop generation expression from inherited columns.
8461 */
8463 {
8464 HeapTuple tuple;
8465 Form_pg_attribute attTup;
8480 }
8481 }
8483 /*
8484 * Return the address of the affected column.
8485 */
8486 static ObjectAddress
8488 {
8489 HeapTuple tuple;
8490 Form_pg_attribute attTup;
8491 AttrNumber attnum;
8492 Relation attrelation;
8493 Oid attrdefoid;
8494 ObjectAddress address;
8511 colName)));
8514 {
8520 else
8521 {
8528 }
8529 }
8531 /*
8532 * Mark the column as no longer generated. (The atthasdef flag needs to
8533 * get cleared too, but RemoveAttrDefault will handle that.)
8534 */
8540 attnum);
8545 /*
8546 * Drop the dependency records of the GENERATED expression, in particular
8547 * its INTERNAL dependency on the column, which would otherwise cause
8548 * dependency.c to refuse to perform the deletion.
8549 */
8556 /* Make above changes visible */
8559 /*
8560 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8561 * safety, but at present we do not expect anything to depend on the
8562 * default.
8563 */
8570 }
8572 /*
8573 * ALTER TABLE ALTER COLUMN SET STATISTICS
8574 *
8575 * Return value is the address of the modified column
8576 */
8577 static ObjectAddress
8578 ATExecSetStatistics(Relation rel, const char *colName, int16 colNum, Node *newValue, LOCKMODE lockmode)
8579 {
8582 Relation attrelation;
8583 HeapTuple tuple,
8584 newtuple;
8585 Form_pg_attribute attrtuple;
8586 AttrNumber attnum;
8587 ObjectAddress address;
8592 /*
8593 * We allow referencing columns by numbers only for indexes, since table
8594 * column numbers could contain gaps if columns are later dropped.
8595 */
8603 /* -1 was used in previous versions for the default setting */
8605 {
8608 }
8609 else
8613 {
8614 /*
8615 * Limit target to a sane range
8616 */
8618 {
8622 newtarget)));
8623 }
8625 {
8630 newtarget)));
8631 }
8632 }
8637 {
8645 }
8646 else
8647 {
8655 }
8664 colName)));
8668 {
8680 }
8682 /* Build new tuple. */
8687 else
8707 }
8709 /*
8710 * Return value is the address of the modified column
8711 */
8712 static ObjectAddress
8715 {
8716 Relation attrelation;
8717 HeapTuple tuple,
8718 newtuple;
8719 Form_pg_attribute attrtuple;
8720 AttrNumber attnum;
8721 Datum datum,
8722 newOptions;
8724 ObjectAddress address;
8745 colName)));
8747 /* Generate new proposed attoptions (text array) */
8753 /* Validate new options */
8756 /* Build new tuple. */
8761 else
8767 /* Update system catalog. */
8783 }
8785 /*
8786 * Helper function for ATExecSetStorage and ATExecSetCompression
8787 *
8788 * Set the attstorage and/or attcompression fields for index columns
8789 * associated with the specified table column.
8790 */
8791 static void
8793 AttrNumber attnum,
8796 LOCKMODE lockmode)
8797 {
8801 {
8803 Relation indrel;
8805 HeapTuple tuple;
8810 {
8812 {
8815 }
8816 }
8819 {
8822 }
8827 {
8843 }
8846 }
8847 }
8849 /*
8850 * ALTER TABLE ALTER COLUMN SET STORAGE
8851 *
8852 * Return value is the address of the modified column
8853 */
8854 static ObjectAddress
8856 {
8857 Relation attrelation;
8858 HeapTuple tuple;
8859 Form_pg_attribute attrtuple;
8860 AttrNumber attnum;
8861 ObjectAddress address;
8879 colName)));
8889 /*
8890 * Apply the change to indexes as well (only for simple index columns,
8891 * matching behavior of index.c ConstructTupleDescriptor()).
8892 */
8896 lockmode);
8905 }
8908 /*
8909 * ALTER TABLE DROP COLUMN
8910 *
8911 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
8912 * because we have to decide at runtime whether to recurse or not depending
8913 * on whether attinhcount goes to zero or not. (We can't check this in a
8914 * static pre-pass because it won't handle multiple inheritance situations
8915 * correctly.)
8916 */
8917 static void
8921 {
8932 }
8934 /*
8935 * Drops column 'colName' from relation 'rel' and returns the address of the
8936 * dropped column. The column is also dropped (or marked as no longer
8937 * inherited from relation) from the relation's inheritance children, if any.
8938 *
8939 * In the recursive invocations for inheritance child relations, instead of
8940 * dropping the column directly (if to be dropped at all), its object address
8941 * is added to 'addrs', which must be non-NULL in such invocations. All
8942 * columns are dropped at the same time after all the children have been
8943 * checked recursively.
8944 */
8945 static ObjectAddress
8947 DropBehavior behavior,
8951 {
8952 HeapTuple tuple;
8953 Form_pg_attribute targetatt;
8954 AttrNumber attnum;
8956 ObjectAddress object;
8959 /* At top level, permission check was done in ATPrepCmd, else do it */
8963 /* Initialize addrs on the first invocation */
8966 /* since this function recurses, it could be driven to stack overflow */
8972 /*
8973 * get the number of the attribute
8974 */
8977 {
8979 {
8984 }
8985 else
8986 {
8991 }
8992 }
8997 /* Can't drop a system attribute */
9002 colName)));
9004 /*
9005 * Don't drop inherited columns, unless recursing (presumably from a drop
9006 * of the parent column)
9007 */
9012 colName)));
9014 /*
9015 * Don't drop columns used in the partition key, either. (If we let this
9016 * go through, the key column's dependencies would cause a cascaded drop
9017 * of the whole table, which is surely not what the user expected.)
9018 */
9029 /*
9030 * Propagate to children as appropriate. Unlike most other ALTER
9031 * routines, we have to do this one level of recursion at a time; we can't
9032 * use find_all_inheritors to do it in one pass.
9033 */
9034 children =
9038 {
9039 Relation attr_rel;
9042 /*
9043 * In case of a partitioned table, the column must be dropped from the
9044 * partitions as well.
9045 */
9054 {
9056 Relation childrel;
9057 Form_pg_attribute childatt;
9059 /* find_inheritance_children already got lock */
9074 {
9075 /*
9076 * If the child column has other definition sources, just
9077 * decrement its inheritance count; if not, recurse to delete
9078 * it.
9079 */
9081 {
9082 /* Time to delete this child column, too */
9086 }
9087 else
9088 {
9089 /* Child column must survive my deletion */
9094 /* Make update visible */
9096 }
9097 }
9098 else
9099 {
9100 /*
9101 * If we were told to drop ONLY in this table (no recursion),
9102 * we need to mark the inheritors' attributes as locally
9103 * defined rather than inherited.
9104 */
9110 /* Make update visible */
9112 }
9117 }
9119 }
9121 /* Add object to delete */
9128 {
9129 /* Recursion has ended, drop everything that was collected */
9132 }
9135 }
9137 /*
9138 * ALTER TABLE ADD INDEX
9139 *
9140 * There is no such command in the grammar, but parse_utilcmd.c converts
9141 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
9142 * us schedule creation of the index at the appropriate time during ALTER.
9143 *
9144 * Return value is the address of the new index.
9145 */
9146 static ObjectAddress
9149 {
9153 ObjectAddress address;
9158 /* The IndexStmt has already been through transformIndexStmt */
9161 /* suppress schema rights check when rebuilding existing index */
9163 /* skip index build if phase 3 will do it or we're reusing an old one */
9165 /* suppress notices when rebuilding existing index */
9169 stmt,
9175 check_rights,
9177 skip_build,
9178 quiet);
9180 /*
9181 * If TryReuseIndex() stashed a relfilenumber for us, we used it for the
9182 * new index instead of building from scratch. Restore associated fields.
9183 * This may store InvalidSubTransactionId in both fields, in which case
9184 * relcache.c will assume it can rebuild the relcache entry. Hence, do
9185 * this after the CCI that made catalog rows visible to any rebuild. The
9186 * DROP of the old edition of this index will have scheduled the storage
9187 * for deletion at commit, so cancel that pending deletion.
9188 */
9190 {
9197 }
9200 }
9202 /*
9203 * ALTER TABLE ADD STATISTICS
9204 *
9205 * This is no such command in the grammar, but we use this internally to add
9206 * AT_ReAddStatistics subcommands to rebuild extended statistics after a table
9207 * column type change.
9208 */
9209 static ObjectAddress
9212 {
9213 ObjectAddress address;
9217 /* The CreateStatsStmt has already been through transformStatsStmt */
9223 }
9225 /*
9226 * ALTER TABLE ADD CONSTRAINT USING INDEX
9227 *
9228 * Returns the address of the new constraint.
9229 */
9230 static ObjectAddress
9233 {
9235 Relation indexRel;
9240 ObjectAddress address;
9241 bits16 flags;
9247 /*
9248 * Doing this on partitioned tables is not a simple feature to implement,
9249 * so let's punt for now.
9250 */
9262 /* this should have been checked at parse time */
9266 /*
9267 * Determine name to assign to constraint. We require a constraint to
9268 * have the same name as the underlying index; therefore, use the index's
9269 * existing name as the default constraint name, and if the user
9270 * explicitly gives some other name for the constraint, rename the index
9271 * to match.
9272 */
9277 {
9282 }
9284 /* Extra checks needed if making primary key */
9288 /* Note we currently don't support EXCLUSION constraints here */
9291 else
9294 /* Create the catalog entries for the constraint */
9296 INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
9302 index_oid,
9303 InvalidOid,
9304 indexInfo,
9305 constraintName,
9306 constraintType,
9307 flags,
9308 allowSystemTableMods,
9314 }
9316 /*
9317 * ALTER TABLE ADD CONSTRAINT
9318 *
9319 * Return value is the address of the new constraint; if no constraint was
9320 * added, InvalidObjectAddress is returned.
9321 */
9322 static ObjectAddress
9325 LOCKMODE lockmode)
9326 {
9331 /*
9332 * Currently, we only expect to see CONSTR_CHECK and CONSTR_FOREIGN nodes
9333 * arriving here (see the preprocessing done in parse_utilcmd.c). Use a
9334 * switch anyway to make it easier to add more code later.
9335 */
9337 {
9339 address =
9342 lockmode);
9347 /*
9348 * Assign or validate constraint name
9349 */
9351 {
9360 }
9361 else
9367 NIL);
9370 newConstraint,
9372 lockmode);
9378 }
9381 }
9383 /*
9384 * Generate the column-name portion of the constraint name for a new foreign
9385 * key given the list of column names that reference the referenced
9386 * table. This will be passed to ChooseConstraintName along with the parent
9387 * table name and the "fkey" suffix.
9388 *
9389 * We know that less than NAMEDATALEN characters will actually be used, so we
9390 * can truncate the result once we've generated that many.
9391 *
9392 * XXX see also ChooseExtendedStatisticNameAddition and
9393 * ChooseIndexNameAddition.
9394 */
9397 {
9404 {
9410 /*
9411 * At this point we have buflen <= NAMEDATALEN. name should be less
9412 * than NAMEDATALEN already, but use strlcpy for paranoia.
9413 */
9418 }
9420 }
9422 /*
9423 * Add a check constraint to a single table and its children. Returns the
9424 * address of the constraint added to the parent relation, if one gets added,
9425 * or InvalidObjectAddress otherwise.
9426 *
9427 * Subroutine for ATExecAddConstraint.
9428 *
9429 * We must recurse to child tables during execution, rather than using
9430 * ALTER TABLE's normal prep-time recursion. The reason is that all the
9431 * constraints *must* be given the same name, else they won't be seen as
9432 * related later. If the user didn't explicitly specify a name, then
9433 * AddRelationNewConstraints would normally assign different names to the
9434 * child constraints. To fix that, we must capture the name assigned at
9435 * the parent table and pass that down.
9436 */
9437 static ObjectAddress
9441 {
9448 /* At top level, permission check was done in ATPrepCmd, else do it */
9452 /*
9453 * Call AddRelationNewConstraints to do the work, making sure it works on
9454 * a copy of the Constraint so transformExpr can't modify the original. It
9455 * returns a list of cooked constraints.
9456 *
9457 * If the constraint ends up getting merged with a pre-existing one, it's
9458 * omitted from the returned list, which is what we want: we do not need
9459 * to do any validation work. That can only happen at child tables,
9460 * though, since we disallow merging at the top level.
9461 */
9468 * here */
9470 /* we don't expect more than one constraint here */
9473 /* Add each to-be-validated constraint to Phase 3's queue */
9475 {
9479 {
9488 }
9490 /* Save the actually assigned name if it was defaulted */
9495 }
9497 /* At this point we must have a locked-down name to use */
9500 /* Advance command counter in case same table is visited multiple times */
9503 /*
9504 * If the constraint got merged with an existing constraint, we're done.
9505 * We mustn't recurse to child tables in this case, because they've
9506 * already got the constraint, and visiting them again would lead to an
9507 * incorrect value for coninhcount.
9508 */
9512 /*
9513 * If adding a NO INHERIT constraint, no need to find our children.
9514 */
9518 /*
9519 * Propagate to children as appropriate. Unlike most other ALTER
9520 * routines, we have to do this one level of recursion at a time; we can't
9521 * use find_all_inheritors to do it in one pass.
9522 */
9523 children =
9526 /*
9527 * Check if ONLY was specified with ALTER TABLE. If so, allow the
9528 * constraint creation only if there are no children currently. Error out
9529 * otherwise.
9530 */
9537 {
9539 Relation childrel;
9542 /* find_inheritance_children already got lock */
9546 /* Find or create work queue entry for this table */
9549 /* Recurse to child */
9554 }
9557 }
9559 /*
9560 * Add a foreign-key constraint to a single table; return the new constraint's
9561 * address.
9562 *
9563 * Subroutine for ATExecAddConstraint. Must already hold exclusive
9564 * lock on the rel, and have done appropriate validity checks for it.
9565 * We do permissions checks here, however.
9566 *
9567 * When the referenced or referencing tables (or both) are partitioned,
9568 * multiple pg_constraint rows are required -- one for each partitioned table
9569 * and each partition on each side (fortunately, not one for every combination
9570 * thereof). We also need action triggers on each leaf partition on the
9571 * referenced side, and check triggers on each leaf partition on the
9572 * referencing side.
9573 */
9574 static ObjectAddress
9578 {
9579 Relation pkrel;
9591 numpks,
9592 numfkdelsetcols;
9593 Oid indexOid;
9595 ObjectAddress address;
9598 /*
9599 * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
9600 * delete rows out from under us.
9601 */
9604 else
9607 /*
9608 * Validity checks (permission checks wait till we have the column
9609 * numbers)
9610 */
9612 {
9616 errmsg("cannot use ONLY for foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9622 errmsg("cannot add NOT VALID foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9626 }
9641 /*
9642 * References from permanent or unlogged tables to temp tables, and from
9643 * permanent tables to unlogged tables, are disallowed because the
9644 * referenced data can vanish out from under us. References from temp
9645 * tables to any other table type are also disallowed, because other
9646 * backends might need to run the RI triggers on the perm table, but they
9647 * can't reliably see tuples in the local buffers of other backends.
9648 */
9650 {
9674 }
9676 /*
9677 * Look up the referencing attributes to make sure they exist, and record
9678 * their attnums and type OIDs.
9679 */
9691 /*
9692 * If the attribute list for the referenced table was omitted, lookup the
9693 * definition of the primary key and use it. Otherwise, validate the
9694 * supplied attribute list. In either case, discover the index OID and
9695 * index opclasses, and the attnums and type OIDs of the attributes.
9696 */
9698 {
9702 opclasses);
9703 }
9704 else
9705 {
9709 /* Look for an index matching the column list */
9711 opclasses);
9712 }
9714 /*
9715 * Now we can check permissions.
9716 */
9719 /*
9720 * Check some things for generated columns.
9721 */
9723 {
9727 {
9728 /*
9729 * Check restrictions on UPDATE/DELETE actions, per SQL standard
9730 */
9744 }
9745 }
9747 /*
9748 * Look up the equality operators to use in the constraint.
9749 *
9750 * Note that we have to be careful about the difference between the actual
9751 * PK column type and the opclass' declared input type, which might be
9752 * only binary-compatible with it. The declared opcintype is the right
9753 * thing to probe pg_amop with.
9754 */
9760 /*
9761 * On the strength of a previous constraint, we might avoid scanning
9762 * tables to validate this one. See below.
9763 */
9768 {
9771 Oid fktyped;
9772 HeapTuple cla_ht;
9773 Form_pg_opclass cla_tup;
9774 Oid amid;
9775 Oid opfamily;
9776 Oid opcintype;
9777 Oid pfeqop;
9778 Oid ppeqop;
9779 Oid ffeqop;
9780 int16 eqstrategy;
9781 Oid pfeqop_right;
9783 /* We need several fields out of the pg_opclass entry */
9793 /*
9794 * Check it's a btree; currently this can never fail since no other
9795 * index AMs support unique indexes. If we ever did have other types
9796 * of unique indexes, we'd need a way to determine which operator
9797 * strategy number is equality. (Is it reasonable to insist that
9798 * every such index AM use btree's number for equality?)
9799 */
9804 /*
9805 * There had better be a primary equality operator for the index.
9806 * We'll use it for PK = PK comparisons.
9807 */
9809 eqstrategy);
9815 /*
9816 * Are there equality operators that take exactly the FK type? Assume
9817 * we should look through any domain here.
9818 */
9822 eqstrategy);
9824 {
9827 eqstrategy);
9828 }
9829 else
9830 {
9831 /* keep compiler quiet */
9834 }
9837 {
9838 /*
9839 * Otherwise, look for an implicit cast from the FK type to the
9840 * opcintype, and if found, use the primary equality operator.
9841 * This is a bit tricky because opcintype might be a polymorphic
9842 * type such as ANYARRAY or ANYENUM; so what we have to test is
9843 * whether the two actual column types can be concurrently cast to
9844 * that type. (Otherwise, we'd fail to reject combinations such
9845 * as int[] and point[].)
9846 */
9855 COERCION_IMPLICIT))
9856 {
9859 }
9860 }
9875 {
9876 /*
9877 * When a pfeqop changes, revalidate the constraint. We could
9878 * permit intra-opfamily changes, but that adds subtle complexity
9879 * without any concrete benefit for core types. We need not
9880 * assess ppeqop or ffeqop, which RI_Initial_Check() does not use.
9881 */
9884 old_pfeqop_item);
9885 }
9887 {
9888 Oid old_fktype;
9889 Oid new_fktype;
9890 CoercionPathType old_pathtype;
9891 CoercionPathType new_pathtype;
9892 Oid old_castfunc;
9893 Oid new_castfunc;
9897 /*
9898 * Identify coercion pathways from each of the old and new FK-side
9899 * column types to the right (foreign) operand type of the pfeqop.
9900 * We may assume that pg_constraint.conkey is not changing.
9901 */
9909 /*
9910 * Upon a change to the cast from the FK column to its pfeqop
9911 * operand, revalidate the constraint. For this evaluation, a
9912 * binary coercion cast is equivalent to no cast at all. While
9913 * type implementors should design implicit casts with an eye
9914 * toward consistency of operations like equality, we cannot
9915 * assume here that they have done so.
9916 *
9917 * A function with a polymorphic argument could change behavior
9918 * arbitrarily in response to get_fn_expr_argtype(). Therefore,
9919 * when the cast destination is polymorphic, we only avoid
9920 * revalidation if the input type has not changed at all. Given
9921 * just the core data types and operator classes, this requirement
9922 * prevents no would-be optimizations.
9923 *
9924 * If the cast converts from a base type to a domain thereon, then
9925 * that domain type must be the opcintype of the unique index.
9926 * Necessarily, the primary key column must then be of the domain
9927 * type. Since the constraint was previously valid, all values on
9928 * the foreign side necessarily exist on the primary side and in
9929 * turn conform to the domain. Consequently, we need not treat
9930 * domains specially here.
9931 *
9932 * Since we require that all collations share the same notion of
9933 * equality (which they do, because texteq reduces to bitwise
9934 * equality), we don't compare collation here.
9935 *
9936 * We need not directly consider the PK type. It's necessarily
9937 * binary coercible to the opcintype of the unique index column,
9938 * and ri_triggers.c will only deal with PK datums in terms of
9939 * that opcintype. Changing the opcintype also changes pfeqop.
9940 */
9945 }
9950 }
9952 /*
9953 * Create all the constraint and trigger objects, recursing to partitions
9954 * as necessary. First handle the referenced side.
9955 */
9957 indexOid,
9959 numfks,
9960 pkattnum,
9961 fkattnum,
9962 pfeqoperators,
9963 ppeqoperators,
9964 ffeqoperators,
9965 numfkdelsetcols,
9966 fkdelsetcols,
9967 old_check_ok,
9970 /* Now handle the referencing side. */
9972 indexOid,
9974 numfks,
9975 pkattnum,
9976 fkattnum,
9977 pfeqoperators,
9978 ppeqoperators,
9979 ffeqoperators,
9980 numfkdelsetcols,
9981 fkdelsetcols,
9982 old_check_ok,
9983 lockmode,
9986 /*
9987 * Done. Close pk table, but keep lock until we've committed.
9988 */
9992 }
9994 /*
9995 * validateFkOnDeleteSetColumns
9996 * Verifies that columns used in ON DELETE SET NULL/DEFAULT (...)
9997 * column lists are valid.
9998 */
9999 void
10003 {
10005 {
10010 {
10012 {
10015 }
10016 }
10019 {
10024 errmsg("column \"%s\" referenced in ON DELETE SET action must be part of foreign key", col)));
10025 }
10026 }
10027 }
10029 /*
10030 * addFkRecurseReferenced
10031 * subroutine for ATAddForeignKeyConstraint; recurses on the referenced
10032 * side of the constraint
10033 *
10034 * Create pg_constraint rows for the referenced side of the constraint,
10035 * referencing the parent of the referencing side; also create action triggers
10036 * on leaf partitions. If the table is partitioned, recurse to handle each
10037 * partition.
10038 *
10039 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10040 * of an ALTER TABLE sequence.
10041 * fkconstraint is the constraint being added.
10042 * rel is the root referencing relation.
10043 * pkrel is the referenced relation; might be a partition, if recursing.
10044 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10045 * parentConstr is the OID of a parent constraint; InvalidOid if this is a
10046 * top-level constraint.
10047 * numfks is the number of columns in the foreign key
10048 * pkattnum is the attnum array of referenced attributes.
10049 * fkattnum is the attnum array of referencing attributes.
10050 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10051 * (...) clause
10052 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10053 * NULL/DEFAULT clause
10054 * pf/pp/ffeqoperators are OID array of operators between columns.
10055 * old_check_ok signals that this constraint replaces an existing one that
10056 * was already validated (thus this one doesn't need validation).
10057 * parentDelTrigger and parentUpdTrigger, when being recursively called on
10058 * a partition, are the OIDs of the parent action triggers for DELETE and
10059 * UPDATE respectively.
10060 */
10061 static ObjectAddress
10070 {
10071 ObjectAddress address;
10072 Oid constrOid;
10077 Oid deleteTriggerOid,
10078 updateTriggerOid;
10080 /*
10081 * Verify relkind for each referenced partition. At the top level, this
10082 * is redundant with a previous check, but we need it when recursing.
10083 */
10091 /*
10092 * Caller supplies us with a constraint name; however, it may be used in
10093 * this partition, so come up with a different one in that case.
10094 */
10102 else
10106 {
10110 }
10111 else
10112 {
10116 /*
10117 * always inherit for partitioned tables, never for legacy inheritance
10118 */
10120 }
10122 /*
10123 * Record the FK constraint in pg_constraint.
10124 */
10127 CONSTRAINT_FOREIGN,
10131 parentConstr,
10133 fkattnum,
10134 numfks,
10135 numfks,
10137 indexOid,
10139 pkattnum,
10140 pfeqoperators,
10141 ppeqoperators,
10142 ffeqoperators,
10143 numfks,
10146 fkdelsetcols,
10147 numfkdelsetcols,
10151 NULL,
10159 /*
10160 * Mark the child constraint as part of the parent constraint; it must not
10161 * be dropped on its own. (This constraint is deleted when the partition
10162 * is detached, but a special check needs to occur that the partition
10163 * contains no referenced values.)
10164 */
10166 {
10167 ObjectAddress referenced;
10171 }
10173 /* make new constraint visible, in case we add more */
10176 /*
10177 * Create the action triggers that enforce the constraint.
10178 */
10180 fkconstraint,
10185 /*
10186 * If the referenced table is partitioned, recurse on ourselves to handle
10187 * each partition. We need one pg_constraint row created for each
10188 * partition in addition to the pg_constraint row for the parent table.
10189 */
10191 {
10195 {
10196 Relation partRel;
10199 Oid partIndexId;
10203 /*
10204 * Map the attribute numbers in the referenced side of the FK
10205 * definition to match the partition's column layout.
10206 */
10211 {
10215 }
10216 else
10219 /* do the deed */
10229 old_check_ok,
10232 /* Done -- clean up (but keep the lock) */
10235 {
10238 }
10239 }
10240 }
10243 }
10245 /*
10246 * addFkRecurseReferencing
10247 * subroutine for ATAddForeignKeyConstraint and CloneFkReferencing
10248 *
10249 * If the referencing relation is a plain relation, create the necessary check
10250 * triggers that implement the constraint, and set up for Phase 3 constraint
10251 * verification. If the referencing relation is a partitioned table, then
10252 * we create a pg_constraint row for it and recurse on this routine for each
10253 * partition.
10254 *
10255 * We assume that the referenced relation is locked against concurrent
10256 * deletions. If it's a partitioned relation, every partition must be so
10257 * locked.
10258 *
10259 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10260 * of an ALTER TABLE sequence.
10261 * fkconstraint is the constraint being added.
10262 * rel is the referencing relation; might be a partition, if recursing.
10263 * pkrel is the root referenced relation.
10264 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10265 * parentConstr is the OID of the parent constraint (there is always one).
10266 * numfks is the number of columns in the foreign key
10267 * pkattnum is the attnum array of referenced attributes.
10268 * fkattnum is the attnum array of referencing attributes.
10269 * pf/pp/ffeqoperators are OID array of operators between columns.
10270 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10271 * (...) clause
10272 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10273 * NULL/DEFAULT clause
10274 * old_check_ok signals that this constraint replaces an existing one that
10275 * was already validated (thus this one doesn't need validation).
10276 * lockmode is the lockmode to acquire on partitions when recursing.
10277 * parentInsTrigger and parentUpdTrigger, when being recursively called on
10278 * a partition, are the OIDs of the parent check triggers for INSERT and
10279 * UPDATE respectively.
10280 */
10281 static void
10289 {
10290 Oid insertTriggerOid,
10291 updateTriggerOid;
10300 /*
10301 * Add the check triggers to it and, if necessary, schedule it to be
10302 * checked in Phase 3.
10303 *
10304 * If the relation is partitioned, drill down to do it to its partitions.
10305 */
10308 fkconstraint,
10309 parentConstr,
10310 indexOid,
10315 {
10316 /*
10317 * Tell Phase 3 to check that the constraint is satisfied by existing
10318 * rows. We can skip this during table creation, when requested
10319 * explicitly by specifying NOT VALID in an ADD FOREIGN KEY command,
10320 * and when we're recreating a constraint following a SET DATA TYPE
10321 * operation that did not impugn its validity.
10322 */
10324 {
10339 }
10340 }
10342 {
10344 Relation trigrel;
10346 /*
10347 * Triggers of the foreign keys will be manipulated a bunch of times
10348 * in the loop below. To avoid repeatedly opening/closing the trigger
10349 * catalog relation, we open it here and pass it to the subroutines
10350 * called below.
10351 */
10354 /*
10355 * Recurse to take appropriate action on each partition; either we
10356 * find an existing constraint to reparent to ours, or we create a new
10357 * one.
10358 */
10360 {
10368 Oid constrOid;
10369 ObjectAddress address,
10370 referenced;
10381 /* Check whether an existing constraint can be repurposed */
10385 {
10390 partitionId,
10391 parentConstr,
10392 numfks,
10393 mapped_fkattnum,
10394 pkattnum,
10395 pfeqoperators,
10396 insertTriggerOid,
10397 updateTriggerOid,
10398 trigrel))
10399 {
10402 }
10403 }
10405 {
10408 }
10410 /*
10411 * No luck finding a good constraint to reuse; create our own.
10412 */
10420 else
10422 constrOid =
10425 CONSTRAINT_FOREIGN,
10429 parentConstr,
10430 partitionId,
10431 mapped_fkattnum,
10432 numfks,
10433 numfks,
10434 InvalidOid,
10435 indexOid,
10437 pkattnum,
10438 pfeqoperators,
10439 ppeqoperators,
10440 ffeqoperators,
10441 numfks,
10444 fkdelsetcols,
10445 numfkdelsetcols,
10447 NULL,
10448 NULL,
10449 NULL,
10455 /*
10456 * Give this constraint partition-type dependencies on the parent
10457 * constraint as well as the table.
10458 */
10465 /* Make all this visible before recursing */
10468 /* call ourselves to finalize the creation and we're done */
10470 indexOid,
10471 constrOid,
10472 numfks,
10473 pkattnum,
10474 mapped_fkattnum,
10475 pfeqoperators,
10476 ppeqoperators,
10477 ffeqoperators,
10478 numfkdelsetcols,
10479 fkdelsetcols,
10480 old_check_ok,
10481 lockmode,
10482 insertTriggerOid,
10483 updateTriggerOid);
10486 }
10489 }
10490 }
10492 /*
10493 * CloneForeignKeyConstraints
10494 * Clone foreign keys from a partitioned table to a newly acquired
10495 * partition.
10496 *
10497 * partitionRel is a partition of parentRel, so we can be certain that it has
10498 * the same columns with the same datatypes. The columns may be in different
10499 * order, though.
10500 *
10501 * wqueue must be passed to set up phase 3 constraint checking, unless the
10502 * referencing-side partition is known to be empty (such as in CREATE TABLE /
10503 * PARTITION OF).
10504 */
10505 static void
10507 Relation partitionRel)
10508 {
10509 /* This only works for declarative partitioning */
10512 /*
10513 * Clone constraints for which the parent is on the referenced side.
10514 */
10517 /*
10518 * Now clone constraints where the parent is on the referencing side.
10519 */
10521 }
10523 /*
10524 * CloneFkReferenced
10525 * Subroutine for CloneForeignKeyConstraints
10526 *
10527 * Find all the FKs that have the parent relation on the referenced side;
10528 * clone those constraints to the given partition. This is to be called
10529 * when the partition is being created or attached.
10530 *
10531 * This ignores self-referencing FKs; those are handled by CloneFkReferencing.
10532 *
10533 * This recurses to partitions, if the relation being attached is partitioned.
10534 * Recursion is done by calling addFkRecurseReferenced.
10535 */
10536 static void
10538 {
10539 Relation pg_constraint;
10542 SysScanDesc scan;
10544 HeapTuple tuple;
10546 Relation trigrel;
10548 /*
10549 * Search for any constraints where this partition's parent is in the
10550 * referenced side. However, we must not clone any constraint whose
10551 * parent constraint is also going to be cloned, to avoid duplicates. So
10552 * do it in two steps: first construct the list of constraints to clone,
10553 * then go over that list cloning those whose parents are not in the list.
10554 * (We must not rely on the parent being seen first, since the catalog
10555 * scan could return children first.)
10556 */
10564 /* This is a seqscan, as we don't have a usable index ... */
10568 {
10572 }
10576 /*
10577 * Triggers of the foreign keys will be manipulated a bunch of times in
10578 * the loop below. To avoid repeatedly opening/closing the trigger
10579 * catalog relation, we open it here and pass it to the subroutines called
10580 * below.
10581 */
10588 {
10590 Form_pg_constraint constrForm;
10591 Relation fkRel;
10592 Oid indexOid;
10593 Oid partIndexId;
10604 Oid deleteTriggerOid,
10605 updateTriggerOid;
10612 /*
10613 * As explained above: don't try to clone a constraint for which we're
10614 * going to clone the parent.
10615 */
10617 {
10620 }
10622 /*
10623 * Don't clone self-referencing foreign keys, which can be in the
10624 * partitioned table or in the partition-to-be.
10625 */
10628 {
10631 }
10633 /*
10634 * Because we're only expanding the key space at the referenced side,
10635 * we don't need to prevent any operation in the referencing table, so
10636 * AccessShareLock suffices (assumes that dropping the constraint
10637 * acquires AEL).
10638 */
10644 conkey,
10645 confkey,
10646 conpfeqop,
10647 conppeqop,
10648 conffeqop,
10650 confdelsetcols);
10662 /* ->fk_attrs determined below */
10673 /* set up colnames that are used to generate the constraint name */
10675 {
10676 Form_pg_attribute att;
10682 }
10684 /*
10685 * Add the new foreign key constraint pointing to the new partition.
10686 * Because this new partition appears in the referenced side of the
10687 * constraint, we don't need to set up for Phase 3 check.
10688 */
10694 /*
10695 * Get the "action" triggers belonging to the constraint to pass as
10696 * parent OIDs for similar triggers that will be created on the
10697 * partition in addFkRecurseReferenced().
10698 */
10704 fkconstraint,
10705 fkRel,
10706 partitionRel,
10707 partIndexId,
10708 constrOid,
10709 numfks,
10710 mapped_confkey,
10711 conkey,
10712 conpfeqop,
10713 conppeqop,
10714 conffeqop,
10715 numfkdelsetcols,
10716 confdelsetcols,
10718 deleteTriggerOid,
10719 updateTriggerOid);
10723 }
10726 }
10728 /*
10729 * CloneFkReferencing
10730 * Subroutine for CloneForeignKeyConstraints
10731 *
10732 * For each FK constraint of the parent relation in the given list, find an
10733 * equivalent constraint in its partition relation that can be reparented;
10734 * if one cannot be found, create a new constraint in the partition as its
10735 * child.
10736 *
10737 * If wqueue is given, it is used to set up phase-3 verification for each
10738 * cloned constraint; if omitted, we assume that such verification is not
10739 * needed (example: the partition is being created anew).
10740 */
10741 static void
10743 {
10748 Relation trigrel;
10750 /* obtain a list of constraints that we need to clone */
10752 {
10756 }
10758 /*
10759 * Silently do nothing if there's nothing to do. In particular, this
10760 * avoids throwing a spurious error for foreign tables.
10761 */
10770 /*
10771 * Triggers of the foreign keys will be manipulated a bunch of times in
10772 * the loop below. To avoid repeatedly opening/closing the trigger
10773 * catalog relation, we open it here and pass it to the subroutines called
10774 * below.
10775 */
10778 /*
10779 * The constraint key may differ, if the columns in the partition are
10780 * different. This map is used to convert them.
10781 */
10789 {
10791 Form_pg_constraint constrForm;
10792 Relation pkrel;
10793 HeapTuple tuple;
10805 Oid indexOid;
10806 Oid constrOid;
10807 ObjectAddress address,
10808 referenced;
10810 Oid insertTriggerOid,
10811 updateTriggerOid;
10816 parentConstrOid);
10819 /* Don't clone constraints whose parents are being cloned */
10821 {
10824 }
10826 /*
10827 * Need to prevent concurrent deletions. If pkrel is a partitioned
10828 * relation, that means to lock all partitions.
10829 */
10841 /*
10842 * Get the "check" triggers belonging to the constraint to pass as
10843 * parent OIDs for similar triggers that will be created on the
10844 * partition in addFkRecurseReferencing(). They are also passed to
10845 * tryAttachPartitionForeignKey() below to simply assign as parents to
10846 * the partition's existing "check" triggers, that is, if the
10847 * corresponding constraints is deemed attachable to the parent
10848 * constraint.
10849 */
10854 /*
10855 * Before creating a new constraint, see whether any existing FKs are
10856 * fit for the purpose. If one is, attach the parent constraint to
10857 * it, and don't clone anything. This way we avoid the expensive
10858 * verification step and don't end up with a duplicate FK, and we
10859 * don't need to recurse to partitions for this constraint.
10860 */
10863 {
10868 parentConstrOid,
10869 numfks,
10870 mapped_conkey,
10871 confkey,
10872 conpfeqop,
10873 insertTriggerOid,
10874 updateTriggerOid,
10875 trigrel))
10876 {
10880 }
10881 }
10883 {
10886 }
10888 /* No dice. Set up to create our own constraint */
10891 /* ->conname determined below */
10896 /* ->fk_attrs determined below */
10907 {
10908 Form_pg_attribute att;
10914 }
10923 else
10927 constrOid =
10930 CONSTRAINT_FOREIGN,
10934 parentConstrOid,
10936 mapped_conkey,
10937 numfks,
10938 numfks,
10940 indexOid,
10942 confkey,
10943 conpfeqop,
10944 conppeqop,
10945 conffeqop,
10946 numfks,
10949 confdelsetcols,
10950 numfkdelsetcols,
10952 NULL,
10953 NULL,
10954 NULL,
10960 /* Set up partition dependencies for the new constraint */
10968 /* Done with the cloned constraint's tuple */
10971 /* Make all this visible before recursing */
10975 fkconstraint,
10976 partRel,
10977 pkrel,
10978 indexOid,
10979 constrOid,
10980 numfks,
10981 confkey,
10982 mapped_conkey,
10983 conpfeqop,
10984 conppeqop,
10985 conffeqop,
10986 numfkdelsetcols,
10987 confdelsetcols,
10989 AccessExclusiveLock,
10990 insertTriggerOid,
10991 updateTriggerOid);
10993 }
10996 }
10998 /*
10999 * When the parent of a partition receives [the referencing side of] a foreign
11000 * key, we must propagate that foreign key to the partition. However, the
11001 * partition might already have an equivalent foreign key; this routine
11002 * compares the given ForeignKeyCacheInfo (in the partition) to the FK defined
11003 * by the other parameters. If they are equivalent, create the link between
11004 * the two constraints and return true.
11005 *
11006 * If the given FK does not match the one defined by rest of the params,
11007 * return false.
11008 */
11009 static bool
11011 Oid partRelid,
11012 Oid parentConstrOid,
11017 Oid parentInsTrigger,
11018 Oid parentUpdTrigger,
11019 Relation trigrel)
11020 {
11021 HeapTuple parentConstrTup;
11022 Form_pg_constraint parentConstr;
11023 HeapTuple partcontup;
11024 Form_pg_constraint partConstr;
11025 ScanKeyData key;
11026 SysScanDesc scan;
11027 HeapTuple trigtup;
11028 Oid insertTriggerOid,
11029 updateTriggerOid;
11037 /*
11038 * Do some quick & easy initial checks. If any of these fail, we cannot
11039 * use this constraint.
11040 */
11042 {
11045 }
11047 {
11051 {
11054 }
11055 }
11057 /*
11058 * Looks good so far; do some more extensive checks. Presumably the check
11059 * for 'convalidated' could be dropped, since we don't really care about
11060 * that, but let's be careful for now.
11061 */
11074 {
11078 }
11083 /*
11084 * Looks good! Attach this constraint. The action triggers in the new
11085 * partition become redundant -- the parent table already has equivalent
11086 * ones, and those will be able to reach the partition. Remove the ones
11087 * in the partition. We identify them because they have our constraint
11088 * OID, as well as being on the referenced rel.
11089 */
11091 Anum_pg_trigger_tgconstraint,
11097 {
11099 ObjectAddress trigger;
11106 /*
11107 * The constraint is originally set up to contain this trigger as an
11108 * implementation object, so there's a dependency record that links
11109 * the two; however, since the trigger is no longer needed, we remove
11110 * the dependency link in order to be able to drop the trigger while
11111 * keeping the constraint intact.
11112 */
11116 /* make dependency deletion visible to performDeletion */
11121 /* make trigger drop visible, in case the loop iterates */
11123 }
11129 /*
11130 * Like the constraint, attach partition's "check" triggers to the
11131 * corresponding parent triggers.
11132 */
11138 partRelid);
11141 partRelid);
11145 }
11147 /*
11148 * GetForeignKeyActionTriggers
11149 * Returns delete and update "action" triggers of the given relation
11150 * belonging to the given constraint
11151 */
11152 static void
11157 {
11158 ScanKeyData key;
11159 SysScanDesc scan;
11160 HeapTuple trigtup;
11164 Anum_pg_trigger_tgconstraint,
11171 {
11178 /* Only ever look at "action" triggers on the PK side. */
11182 {
11185 }
11187 {
11190 }
11191 #ifndef USE_ASSERT_CHECKING
11192 /* In an assert-enabled build, continue looking to find duplicates */
11195 #endif
11196 }
11200 conoid);
11203 conoid);
11206 }
11208 /*
11209 * GetForeignKeyCheckTriggers
11210 * Returns insert and update "check" triggers of the given relation
11211 * belonging to the given constraint
11212 */
11213 static void
11218 {
11219 ScanKeyData key;
11220 SysScanDesc scan;
11221 HeapTuple trigtup;
11225 Anum_pg_trigger_tgconstraint,
11232 {
11239 /* Only ever look at "check" triggers on the FK side. */
11243 {
11246 }
11248 {
11251 }
11252 #ifndef USE_ASSERT_CHECKING
11253 /* In an assert-enabled build, continue looking to find duplicates. */
11256 #endif
11257 }
11261 conoid);
11264 conoid);
11267 }
11269 /*
11270 * ALTER TABLE ALTER CONSTRAINT
11271 *
11272 * Update the attributes of a constraint.
11273 *
11274 * Currently only works for Foreign Key constraints.
11275 *
11276 * If the constraint is modified, returns its address; otherwise, return
11277 * InvalidObjectAddress.
11278 */
11279 static ObjectAddress
11282 {
11284 Relation conrel;
11285 Relation tgrel;
11286 SysScanDesc scan;
11288 HeapTuple contuple;
11289 Form_pg_constraint currcon;
11290 ObjectAddress address;
11299 /*
11300 * Find and check the target constraint
11301 */
11303 Anum_pg_constraint_conrelid,
11307 Anum_pg_constraint_contypid,
11311 Anum_pg_constraint_conname,
11317 /* There can be at most one matching row */
11331 /*
11332 * If it's not the topmost constraint, raise an error.
11333 *
11334 * Altering a non-topmost constraint leaves some triggers untouched, since
11335 * they are not directly connected to this constraint; also, pg_dump would
11336 * ignore the deferrability status of the individual constraint, since it
11337 * only dumps topmost constraints. Avoid these problems by refusing this
11338 * operation and telling the user to alter the parent constraint instead.
11339 */
11341 {
11342 HeapTuple tp;
11347 /* Loop to find the topmost constraint */
11349 {
11352 /* If no parent, this is the constraint we want */
11354 {
11359 }
11363 }
11373 }
11375 /*
11376 * Do the actual catalog work. We can skip changing if already in the
11377 * desired state, but not if a partitioned table: partitions need to be
11378 * processed regardless, in case they had the constraint locally changed.
11379 */
11384 {
11388 }
11390 /*
11391 * ATExecAlterConstrRecurse already invalidated relcache for the relations
11392 * having the constraint itself; here we also invalidate for relations
11393 * that have any triggers that are part of the constraint.
11394 */
11404 }
11406 /*
11407 * Recursive subroutine of ATExecAlterConstraint. Returns true if the
11408 * constraint is altered.
11409 *
11410 * *otherrelids is appended OIDs of relations containing affected triggers.
11411 *
11412 * Note that we must recurse even when the values are correct, in case
11413 * indirect descendants have had their constraints altered locally.
11414 * (This could be avoided if we forbade altering constraints in partitions
11415 * but existing releases don't do that.)
11416 */
11417 static bool
11420 LOCKMODE lockmode)
11421 {
11422 Form_pg_constraint currcon;
11423 Oid conoid;
11424 Oid refrelid;
11427 /* since this function recurses, it could be driven to stack overflow */
11434 /*
11435 * Update pg_constraint with the flags from cmdcon.
11436 *
11437 * If called to modify a constraint that's already in the desired state,
11438 * silently do nothing.
11439 */
11442 {
11443 HeapTuple copyTuple;
11444 Form_pg_constraint copy_con;
11445 HeapTuple tgtuple;
11446 ScanKeyData tgkey;
11447 SysScanDesc tgscan;
11461 /* Make new constraint flags visible to others */
11464 /*
11465 * Now we need to update the multiple entries in pg_trigger that
11466 * implement the constraint.
11467 */
11469 Anum_pg_trigger_tgconstraint,
11475 {
11477 Form_pg_trigger copy_tg;
11478 HeapTuple tgCopyTuple;
11480 /*
11481 * Remember OIDs of other relation(s) involved in FK constraint.
11482 * (Note: it's likely that we could skip forcing a relcache inval
11483 * for other rels that don't have a trigger whose properties
11484 * change, but let's be conservative.)
11485 */
11490 /*
11491 * Update deferrability of RI_FKey_noaction_del,
11492 * RI_FKey_noaction_upd, RI_FKey_check_ins and RI_FKey_check_upd
11493 * triggers, but not others; see createForeignKeyActionTriggers
11494 * and CreateFKCheckTrigger.
11495 */
11512 }
11515 }
11517 /*
11518 * If the table at either end of the constraint is partitioned, we need to
11519 * recurse and handle every constraint that is a child of this one.
11520 *
11521 * (This assumes that the recurse flag is forcibly set for partitioned
11522 * tables, and not set for legacy inheritance, though we don't check for
11523 * that here.)
11524 */
11527 {
11528 ScanKeyData pkey;
11529 SysScanDesc pscan;
11530 HeapTuple childtup;
11533 Anum_pg_constraint_conparentid,
11541 {
11543 Relation childrel;
11549 }
11552 }
11555 }
11557 /*
11558 * ALTER TABLE VALIDATE CONSTRAINT
11559 *
11560 * XXX The reason we handle recursion here rather than at Phase 1 is because
11561 * there's no good way to skip recursing when handling foreign keys: there is
11562 * no need to lock children in that case, yet we wouldn't be able to avoid
11563 * doing so at that level.
11564 *
11565 * Return value is the address of the validated constraint. If the constraint
11566 * was already validated, InvalidObjectAddress is returned.
11567 */
11568 static ObjectAddress
11571 {
11572 Relation conrel;
11573 SysScanDesc scan;
11575 HeapTuple tuple;
11576 Form_pg_constraint con;
11577 ObjectAddress address;
11581 /*
11582 * Find and check the target constraint
11583 */
11585 Anum_pg_constraint_conrelid,
11589 Anum_pg_constraint_contypid,
11593 Anum_pg_constraint_conname,
11599 /* There can be at most one matching row */
11615 {
11617 HeapTuple copyTuple;
11618 Form_pg_constraint copy_con;
11621 {
11625 /* Queue validation for phase 3 */
11627 /* for now this is all we need */
11638 /* Find or create work queue entry for this table */
11642 /*
11643 * We disallow creating invalid foreign keys to or from
11644 * partitioned tables, so ignoring the recursion bit is okay.
11645 */
11646 }
11648 {
11652 Datum val;
11655 /*
11656 * If we're recursing, the parent has already done this, so skip
11657 * it. Also, if the constraint is a NO INHERIT constraint, we
11658 * shouldn't try to look for it in the children.
11659 */
11664 /*
11665 * For CHECK constraints, we must ensure that we only mark the
11666 * constraint as validated on the parent if it's already validated
11667 * on the children.
11668 *
11669 * We recurse before validating on the parent, to reduce risk of
11670 * deadlocks.
11671 */
11673 {
11675 Relation childrel;
11680 /*
11681 * If we are told not to recurse, there had better not be any
11682 * child tables, because we can't mark the constraint on the
11683 * parent valid unless it is valid for all child tables.
11684 */
11690 /* find_all_inheritors already got lock */
11696 }
11698 /* Queue validation for phase 3 */
11707 Anum_pg_constraint_conbin);
11711 /* Find or create work queue entry for this table */
11715 /*
11716 * Invalidate relcache so that others see the new validated
11717 * constraint.
11718 */
11720 }
11722 /*
11723 * Now update the catalog, while we have the door open.
11724 */
11735 }
11736 else
11744 }
11747 /*
11748 * transformColumnNameList - transform list of column names
11749 *
11750 * Lookup each name and return its attnum and, optionally, type OID
11751 *
11752 * Note: the name of this function suggests that it's general-purpose,
11753 * but actually it's only used to look up names appearing in foreign-key
11754 * clauses. The error messages would need work to use it in other cases,
11755 * and perhaps the validity checks as well.
11756 */
11757 static int
11760 {
11766 {
11768 HeapTuple atttuple;
11769 Form_pg_attribute attform;
11776 attname)));
11786 INDEX_MAX_KEYS)));
11791 attnum++;
11792 }
11795 }
11797 /*
11798 * transformFkeyGetPrimaryKey -
11799 *
11800 * Look up the names, attnums, and types of the primary key attributes
11801 * for the pkrel. Also return the index OID and index opclasses of the
11802 * index supporting the primary key.
11803 *
11804 * All parameters except pkrel are output parameters. Also, the function
11805 * return value is the number of attributes in the primary key.
11806 *
11807 * Used when the column list in the REFERENCES specification is omitted.
11808 */
11809 static int
11814 {
11819 Datum indclassDatum;
11823 /*
11824 * Get the list of index OIDs for the table from the relcache, and look up
11825 * each one in the pg_index syscache until we find one marked primary key
11826 * (hopefully there isn't more than one such). Insist it's valid, too.
11827 */
11833 {
11841 {
11842 /*
11843 * Refuse to use a deferrable primary key. This is per SQL spec,
11844 * and there would be a lot of interesting semantic problems if we
11845 * tried to allow it.
11846 */
11855 }
11857 }
11861 /*
11862 * Check that we found it
11863 */
11870 /* Must get indclass the hard way */
11872 Anum_pg_index_indclass);
11875 /*
11876 * Now build the list of PK attributes from the indkey definition (we
11877 * assume a primary key cannot have expressional elements)
11878 */
11881 {
11889 }
11894 }
11896 /*
11897 * transformFkeyCheckAttrs -
11898 *
11899 * Validate that the 'attnums' columns in the 'pkrel' relation are valid to
11900 * reference as part of a foreign key constraint.
11901 *
11902 * Returns the OID of the unique index supporting the constraint and
11903 * populates the caller-provided 'opclasses' array with the opclasses
11904 * associated with the index columns.
11905 *
11906 * Raises an ERROR on validation failure.
11907 */
11908 static Oid
11912 {
11919 j;
11921 /*
11922 * Reject duplicate appearances of columns in the referenced-columns list.
11923 * Such a case is forbidden by the SQL standard, and even if we thought it
11924 * useful to allow it, there would be ambiguity about how to match the
11925 * list to unique indexes (in particular, it'd be unclear which index
11926 * opclass goes with which FK column).
11927 */
11929 {
11931 {
11936 }
11937 }
11939 /*
11940 * Get the list of index OIDs for the table from the relcache, and look up
11941 * each one in the pg_index syscache, and match unique indexes to the list
11942 * of attnums we are given.
11943 */
11947 {
11948 HeapTuple indexTuple;
11949 Form_pg_index indexStruct;
11957 /*
11958 * Must have the right number of columns; must be unique and not a
11959 * partial index; forget it if there are any expressions, too. Invalid
11960 * indexes are out as well.
11961 */
11967 {
11968 Datum indclassDatum;
11971 /* Must get indclass the hard way */
11973 Anum_pg_index_indclass);
11976 /*
11977 * The given attnum list may match the index columns in any order.
11978 * Check for a match, and extract the appropriate opclasses while
11979 * we're at it.
11980 *
11981 * We know that attnums[] is duplicate-free per the test at the
11982 * start of this function, and we checked above that the number of
11983 * index columns agrees, so if we find a match for each attnums[]
11984 * entry then we must have a one-to-one match in some order.
11985 */
11987 {
11990 {
11992 {
11996 }
11997 }
12000 }
12002 /*
12003 * Refuse to use a deferrable unique/primary key. This is per SQL
12004 * spec, and there would be a lot of interesting semantic problems
12005 * if we tried to allow it.
12006 */
12008 {
12009 /*
12010 * Remember that we found an otherwise matching index, so that
12011 * we can generate a more appropriate error message.
12012 */
12015 }
12016 }
12020 }
12023 {
12029 else
12034 }
12039 }
12041 /*
12042 * findFkeyCast -
12043 *
12044 * Wrapper around find_coercion_pathway() for ATAddForeignKeyConstraint().
12045 * Caller has equal regard for binary coercibility and for an exact match.
12046 */
12047 static CoercionPathType
12049 {
12050 CoercionPathType ret;
12053 {
12056 }
12057 else
12058 {
12062 /* A previously-relied-upon cast is now gone. */
12065 }
12068 }
12070 /*
12071 * Permissions checks on the referenced table for ADD FOREIGN KEY
12072 *
12073 * Note: we have already checked that the user owns the referencing table,
12074 * else we'd have failed much earlier; no additional checks are needed for it.
12075 */
12076 static void
12078 {
12080 AclResult aclresult;
12083 /* Okay if we have relation-level REFERENCES permission */
12085 ACL_REFERENCES);
12088 /* Else we must have REFERENCES on each column */
12090 {
12096 }
12097 }
12099 /*
12100 * Scan the existing rows in a table to verify they meet a proposed FK
12101 * constraint.
12102 *
12103 * Caller must have opened and locked both relations appropriately.
12104 */
12105 static void
12107 Relation rel,
12108 Relation pkrel,
12109 Oid pkindOid,
12110 Oid constraintOid)
12111 {
12113 TableScanDesc scan;
12115 Snapshot snapshot;
12116 MemoryContext oldcxt;
12117 MemoryContext perTupCxt;
12122 /*
12123 * Build a trigger call structure; we'll need it either way.
12124 */
12134 /* we needn't fill in remaining fields */
12136 /*
12137 * See if we can do it with a single LEFT JOIN query. A false result
12138 * indicates we must proceed with the fire-the-trigger method.
12139 */
12143 /*
12144 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
12145 * if that tuple had just been inserted. If any of those fail, it should
12146 * ereport(ERROR) and that's that.
12147 */
12154 ALLOCSET_SMALL_SIZES);
12158 {
12164 /*
12165 * Make a call to the trigger function
12166 *
12167 * No parameters are passed, but we do set a context
12168 */
12171 /*
12172 * We assume RI_FKey_check_ins won't look at flinfo...
12173 */
12186 }
12193 }
12195 /*
12196 * CreateFKCheckTrigger
12197 * Creates the insert (on_insert=true) or update "check" trigger that
12198 * implements a given foreign key
12199 *
12200 * Returns the OID of the so created trigger.
12201 */
12202 static Oid
12206 {
12207 ObjectAddress trigAddress;
12210 /*
12211 * Note: for a self-referential FK (referencing and referenced tables are
12212 * the same), it is important that the ON UPDATE action fires before the
12213 * CHECK action, since both triggers will fire on the same row during an
12214 * UPDATE event; otherwise the CHECK trigger will be checking a non-final
12215 * state of the row. Triggers fire in name order, so we ensure this by
12216 * using names like "RI_ConstraintTrigger_a_NNNN" for the action triggers
12217 * and "RI_ConstraintTrigger_c_NNNN" for the check triggers.
12218 */
12225 /* Either ON INSERT or ON UPDATE */
12227 {
12230 }
12231 else
12232 {
12235 }
12251 /* Make changes-so-far visible */
12255 }
12257 /*
12258 * createForeignKeyActionTriggers
12259 * Create the referenced-side "action" triggers that implement a foreign
12260 * key.
12261 *
12262 * Returns the OIDs of the so created triggers in *deleteTrigOid and
12263 * *updateTrigOid.
12264 */
12265 static void
12270 {
12272 ObjectAddress trigAddress;
12274 /*
12275 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12276 * DELETE action on the referenced table.
12277 */
12292 {
12322 }
12331 /* Make changes-so-far visible */
12334 /*
12335 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12336 * UPDATE action on the referenced table.
12337 */
12352 {
12382 }
12390 }
12392 /*
12393 * createForeignKeyCheckTriggers
12394 * Create the referencing-side "check" triggers that implement a foreign
12395 * key.
12396 *
12397 * Returns the OIDs of the so created triggers in *insertTrigOid and
12398 * *updateTrigOid.
12399 */
12400 static void
12403 Oid indexOid,
12406 {
12413 }
12415 /*
12416 * ALTER TABLE DROP CONSTRAINT
12417 *
12418 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
12419 */
12420 static void
12422 DropBehavior behavior,
12425 {
12427 Relation conrel;
12428 Form_pg_constraint con;
12429 SysScanDesc scan;
12431 HeapTuple tuple;
12436 /* At top level, permission check was done in ATPrepCmd, else do it */
12442 /*
12443 * Find and drop the target constraint
12444 */
12446 Anum_pg_constraint_conrelid,
12450 Anum_pg_constraint_contypid,
12454 Anum_pg_constraint_conname,
12460 /* There can be at most one matching row */
12462 {
12463 ObjectAddress conobj;
12467 /* Don't drop inherited constraints */
12477 /*
12478 * If it's a foreign-key constraint, we'd better lock the referenced
12479 * table and check that that's not in use, just as we've already done
12480 * for the constrained table (else we might, eg, be dropping a trigger
12481 * that has unfired events). But we can/must skip that in the
12482 * self-referential case.
12483 */
12486 {
12487 Relation frel;
12489 /* Must match lock taken by RemoveTriggerById: */
12493 }
12495 /*
12496 * Perform the actual constraint deletion
12497 */
12505 }
12510 {
12512 {
12517 }
12518 else
12519 {
12525 }
12526 }
12528 /*
12529 * For partitioned tables, non-CHECK inherited constraints are dropped via
12530 * the dependency mechanism, so we're done here.
12531 */
12534 {
12537 }
12539 /*
12540 * Propagate to children as appropriate. Unlike most other ALTER
12541 * routines, we have to do this one level of recursion at a time; we can't
12542 * use find_all_inheritors to do it in one pass.
12543 */
12546 else
12549 /*
12550 * For a partitioned table, if partitions exist and we are told not to
12551 * recurse, it's a user error. It doesn't make sense to have a constraint
12552 * be defined only on the parent, especially if it's a partitioned table.
12553 */
12562 {
12563 Relation childrel;
12564 HeapTuple copy_tuple;
12566 /* find_inheritance_children already got lock */
12571 Anum_pg_constraint_conrelid,
12575 Anum_pg_constraint_contypid,
12579 Anum_pg_constraint_conname,
12585 /* There can be at most one matching row */
12590 constrName,
12599 /* Right now only CHECK constraints can be inherited */
12608 {
12609 /*
12610 * If the child constraint has other definition sources, just
12611 * decrement its inheritance count; if not, recurse to delete it.
12612 */
12614 {
12615 /* Time to delete this child constraint, too */
12619 }
12620 else
12621 {
12622 /* Child constraint must survive my deletion */
12626 /* Make update visible */
12628 }
12629 }
12630 else
12631 {
12632 /*
12633 * If we were told to drop ONLY in this table (no recursion), we
12634 * need to mark the inheritors' constraints as locally defined
12635 * rather than inherited.
12636 */
12642 /* Make update visible */
12644 }
12649 }
12652 }
12654 /*
12655 * ALTER COLUMN TYPE
12656 *
12657 * Unlike other subcommand types, we do parse transformation for ALTER COLUMN
12658 * TYPE during phase 1 --- the AlterTableCmd passed in here is already
12659 * transformed (and must be, because we rely on some transformed fields).
12660 *
12661 * The point of this is that the execution of all ALTER COLUMN TYPEs for a
12662 * table will be done "in parallel" during phase 3, so all the USING
12663 * expressions should be parsed assuming the original column types. Also,
12664 * this allows a USING expression to refer to a field that will be dropped.
12665 *
12666 * To make this work safely, AT_PASS_DROP then AT_PASS_ALTER_TYPE must be
12667 * the first two execution steps in phase 2; they must not see the effects
12668 * of any other subcommand types, since the USING expressions are parsed
12669 * against the unmodified table's state.
12670 */
12671 static void
12677 {
12682 HeapTuple tuple;
12683 Form_pg_attribute attTup;
12684 AttrNumber attnum;
12685 Oid targettype;
12686 int32 targettypmod;
12687 Oid targetcollid;
12690 AclResult aclresult;
12698 /* lookup the attribute so we can check inheritance status */
12708 /* Can't alter a system attribute */
12713 colName)));
12715 /*
12716 * Don't alter inherited columns. At outer level, there had better not be
12717 * any inherited definition; when recursing, we assume this was checked at
12718 * the parent level (see below).
12719 */
12724 colName)));
12726 /* Don't alter columns used in the partition key */
12732 errmsg("cannot alter column \"%s\" because it is part of the partition key of relation \"%s\"",
12735 /* Look up the target type */
12742 /* And the collation */
12745 /* make sure datatype is legal for a column */
12752 {
12753 /*
12754 * Set up an expression to transform the old data value to the new
12755 * type. If a USING option was given, use the expression as
12756 * transformed by transformAlterTableStmt, else just take the old
12757 * value and try to coerce it. We do this first so that type
12758 * incompatibility can be detected before we waste effort, and because
12759 * we need the expression to be parsed against the original table row
12760 * type.
12761 */
12763 {
12768 }
12773 COERCION_ASSIGNMENT,
12774 COERCE_IMPLICIT_CAST,
12777 {
12778 /* error text depends on whether USING was specified or not */
12786 else
12791 /* translator: USING is SQL, don't translate it */
12795 targettypmod))));
12796 }
12798 /* Fix collations after all else */
12801 /* Plan the expr now so we can accurately assess the need to rewrite. */
12804 /*
12805 * Add a work queue item to make ATRewriteTable update the column
12806 * contents.
12807 */
12816 }
12824 {
12825 /*
12826 * For relations without storage, do this check now. Regular tables
12827 * will check it later when the table is being rewritten.
12828 */
12830 }
12834 /*
12835 * Recurse manually by queueing a new command for each child, if
12836 * necessary. We cannot apply ATSimpleRecursion here because we need to
12837 * remap attribute numbers in the USING expression, if any.
12838 *
12839 * If we are told not to recurse, there had better not be any child
12840 * tables; else the alter would put them out of step.
12841 */
12843 {
12853 /*
12854 * find_all_inheritors does the recursive search of the inheritance
12855 * hierarchy, so all we have to do is process all of the relids in the
12856 * list that it returns.
12857 */
12859 {
12862 Relation childrel;
12863 HeapTuple childtuple;
12864 Form_pg_attribute childattTup;
12869 /* find_all_inheritors already got lock */
12873 /*
12874 * Verify that the child doesn't have any inherited definitions of
12875 * this column that came from outside this inheritance hierarchy.
12876 * (renameatt makes a similar test, though in a different way
12877 * because of its different recursion mechanism.)
12878 */
12880 colName);
12896 /*
12897 * Remap the attribute numbers. If no USING expression was
12898 * specified, there is no need for this step.
12899 */
12901 {
12905 /* create a copy to scribble on */
12914 attmap,
12922 }
12925 }
12926 }
12932 colName)));
12936 }
12938 /*
12939 * When the data type of a column is changed, a rewrite might not be required
12940 * if the new type is sufficiently identical to the old one, and the USING
12941 * clause isn't trying to insert some other value. It's safe to skip the
12942 * rewrite in these cases:
12943 *
12944 * - the old type is binary coercible to the new type
12945 * - the new type is an unconstrained domain over the old type
12946 * - {NEW,OLD} or {OLD,NEW} is {timestamptz,timestamp} and the timezone is UTC
12947 *
12948 * In the case of a constrained domain, we could get by with scanning the
12949 * table and checking the constraint rather than actually rewriting it, but we
12950 * don't currently try to do that.
12951 */
12952 static bool
12954 {
12958 {
12959 /* only one varno, so no need to check that */
12965 {
12971 }
12973 {
12977 {
12982 else
12987 }
12988 }
12989 else
12991 }
12992 }
12994 /*
12995 * ALTER COLUMN .. SET DATA TYPE
12996 *
12997 * Return the address of the modified column.
12998 */
12999 static ObjectAddress
13002 {
13006 HeapTuple heapTup;
13007 Form_pg_attribute attTup,
13008 attOldTup;
13009 AttrNumber attnum;
13010 HeapTuple typeTuple;
13011 Form_pg_type tform;
13012 Oid targettype;
13013 int32 targettypmod;
13014 Oid targetcollid;
13016 Relation attrelation;
13017 Relation depRel;
13019 SysScanDesc scan;
13020 HeapTuple depTup;
13021 ObjectAddress address;
13023 /*
13024 * Clear all the missing values if we're rewriting the table, since this
13025 * renders them pointless.
13026 */
13028 {
13029 Relation newrel;
13034 /* make sure we don't conflict with later attribute modifications */
13036 }
13040 /* Look up the target column */
13051 /* Check for multiple ALTER TYPE on same column --- can't cope */
13057 colName)));
13059 /* Look up the target type (should not fail, since prep found it) */
13063 /* And the collation */
13066 /*
13067 * If there is a default expression for the column, get it and ensure we
13068 * can coerce it to the new datatype. (We must do this before changing
13069 * the column type, because build_column_default itself will try to
13070 * coerce, and will not issue the error message we want if it fails.)
13071 *
13072 * We remove any implicit coercion steps at the top level of the old
13073 * default expression; this has been agreed to satisfy the principle of
13074 * least surprise. (The conversion to the new column type should act like
13075 * it started from what the user sees as the stored expression, and the
13076 * implicit coercions aren't going to be shown.)
13077 */
13079 {
13086 COERCION_ASSIGNMENT,
13087 COERCE_IMPLICIT_CAST,
13090 {
13096 else
13101 }
13102 }
13103 else
13106 /*
13107 * Find everything that depends on the column (constraints, indexes, etc),
13108 * and record enough information to let us recreate the objects.
13109 *
13110 * The actual recreation does not happen here, but only after we have
13111 * performed all the individual ALTER TYPE operations. We have to save
13112 * the info before executing ALTER TYPE, though, else the deparser will
13113 * get confused.
13114 */
13117 /*
13118 * Now scan for dependencies of this column on other things. The only
13119 * things we should find are the dependency on the column datatype and
13120 * possibly a collation dependency. Those can be removed.
13121 */
13125 Anum_pg_depend_classid,
13129 Anum_pg_depend_objid,
13133 Anum_pg_depend_objsubid,
13141 {
13143 ObjectAddress foundObject;
13160 }
13166 /*
13167 * Here we go --- change the recorded column type and collation. (Note
13168 * heapTup is a copy of the syscache entry, so okay to scribble on.) First
13169 * fix up the missing value if any.
13170 */
13172 {
13173 Datum missingval;
13176 /* if rewrite is true the missing value should already be cleared */
13179 /* Get the missing value datum */
13181 Anum_pg_attribute_attmissingval,
13185 /* if it's a null array there is nothing to do */
13188 {
13189 /*
13190 * Get the datum out of the array and repack it in a new array
13191 * built with the new type data. We assume that since the table
13192 * doesn't need rewriting, the actual Datum doesn't need to be
13193 * changed, only the array metadata.
13194 */
13201 HeapTuple newTup;
13213 targettype,
13227 }
13228 }
13250 /* Install dependencies on new datatype and collation */
13254 /*
13255 * Drop any pg_statistic entry for the column, since it's now wrong type
13256 */
13262 /*
13263 * Update the default, if present, by brute force --- remove and re-add
13264 * the default. Probably unsafe to take shortcuts, since the new version
13265 * may well have additional dependencies. (It's okay to do this now,
13266 * rather than after other ALTER TYPE commands, since the default won't
13267 * depend on other column types.)
13268 */
13270 {
13271 /*
13272 * If it's a GENERATED default, drop its dependency records, in
13273 * particular its INTERNAL dependency on the column, which would
13274 * otherwise cause dependency.c to refuse to perform the deletion.
13275 */
13277 {
13284 }
13286 /*
13287 * Make updates-so-far visible, particularly the new pg_attribute row
13288 * which will be updated again.
13289 */
13292 /*
13293 * We use RESTRICT here for safety, but at present we do not expect
13294 * anything to depend on the default.
13295 */
13300 }
13305 /* Cleanup */
13309 }
13311 /*
13312 * Subroutine for ATExecAlterColumnType and ATExecSetExpression: Find everything
13313 * that depends on the column (constraints, indexes, etc), and record enough
13314 * information to let us recreate the objects.
13315 */
13316 static void
13319 {
13320 Relation depRel;
13322 SysScanDesc scan;
13323 HeapTuple depTup;
13330 Anum_pg_depend_refclassid,
13334 Anum_pg_depend_refobjid,
13338 Anum_pg_depend_refobjsubid,
13346 {
13348 ObjectAddress foundObject;
13355 {
13357 {
13362 {
13365 }
13367 {
13368 /*
13369 * This must be a SERIAL column's sequence. We need
13370 * not do anything to it.
13371 */
13373 }
13374 else
13375 {
13376 /* Not expecting any other direct dependencies... */
13379 }
13381 }
13390 /*
13391 * A new-style SQL function can depend on a column, if that
13392 * column is referenced in the parsed function body. Ideally
13393 * we'd automatically update the function by deparsing and
13394 * reparsing it, but that's risky and might well fail anyhow.
13395 * FIXME someday.
13396 *
13397 * This is only a problem for AT_AlterColumnType, not
13398 * AT_SetExpression.
13399 */
13406 colName)));
13411 /*
13412 * View/rule bodies have pretty much the same issues as
13413 * function bodies. FIXME someday.
13414 */
13421 colName)));
13426 /*
13427 * A trigger can depend on a column because the column is
13428 * specified as an update target, or because the column is
13429 * used in the trigger's WHEN condition. The first case would
13430 * not require any extra work, but the second case would
13431 * require updating the WHEN expression, which has the same
13432 * issues as above. Since we can't easily tell which case
13433 * applies, we punt for both. FIXME someday.
13434 */
13441 colName)));
13446 /*
13447 * A policy can depend on a column because the column is
13448 * specified in the policy's USING or WITH CHECK qual
13449 * expressions. It might be possible to rewrite and recheck
13450 * the policy expression, but punt for now. It's certainly
13451 * easy enough to remove and recreate the policy; still, FIXME
13452 * someday.
13453 */
13460 colName)));
13464 {
13469 {
13470 /*
13471 * Ignore the column's own default expression. The
13472 * caller deals with it.
13473 */
13474 }
13475 else
13476 {
13477 /*
13478 * This must be a reference from the expression of a
13479 * generated column elsewhere in the same table.
13480 * Changing the type/generated expression of a column
13481 * that is used by a generated column is not allowed
13482 * by SQL standard, so just punt for now. It might be
13483 * doable with some thinking and effort.
13484 */
13490 colName,
13494 }
13496 }
13500 /*
13501 * Give the extended-stats machinery a chance to fix anything
13502 * that this column type change would break.
13503 */
13509 /*
13510 * Column reference in a PUBLICATION ... FOR TABLE ... WHERE
13511 * clause. Same issues as above. FIXME someday.
13512 */
13519 colName)));
13524 /*
13525 * We don't expect any other sorts of objects to depend on a
13526 * column.
13527 */
13531 }
13532 }
13536 }
13538 /*
13539 * Subroutine for ATExecAlterColumnType: remember that a replica identity
13540 * needs to be reset.
13541 */
13542 static void
13544 {
13552 }
13554 /*
13555 * Subroutine for ATExecAlterColumnType: remember any clustered index.
13556 */
13557 static void
13559 {
13567 }
13569 /*
13570 * Subroutine for ATExecAlterColumnType: remember that a constraint needs
13571 * to be rebuilt (which we might already know).
13572 */
13573 static void
13575 {
13576 /*
13577 * This de-duplication check is critical for two independent reasons: we
13578 * mustn't try to recreate the same constraint twice, and if a constraint
13579 * depends on more than one column whose type is to be altered, we must
13580 * capture its definition string before applying any of the column type
13581 * changes. ruleutils.c will get confused if we ask again later.
13582 */
13584 {
13585 /* OK, capture the constraint's existing definition string */
13587 Oid indoid;
13590 conoid);
13592 defstring);
13594 /*
13595 * For the index of a constraint, if any, remember if it is used for
13596 * the table's replica identity or if it is a clustered index, so that
13597 * ATPostAlterTypeCleanup() can queue up commands necessary to restore
13598 * those properties.
13599 */
13602 {
13605 }
13606 }
13607 }
13609 /*
13610 * Subroutine for ATExecAlterColumnType: remember that an index needs
13611 * to be rebuilt (which we might already know).
13612 */
13613 static void
13615 {
13616 /*
13617 * This de-duplication check is critical for two independent reasons: we
13618 * mustn't try to recreate the same index twice, and if an index depends
13619 * on more than one column whose type is to be altered, we must capture
13620 * its definition string before applying any of the column type changes.
13621 * ruleutils.c will get confused if we ask again later.
13622 */
13624 {
13625 /*
13626 * Before adding it as an index-to-rebuild, we'd better see if it
13627 * belongs to a constraint, and if so rebuild the constraint instead.
13628 * Typically this check fails, because constraint indexes normally
13629 * have only dependencies on their constraint. But it's possible for
13630 * such an index to also have direct dependencies on table columns,
13631 * for example with a partial exclusion constraint.
13632 */
13636 {
13638 }
13639 else
13640 {
13641 /* OK, capture the index's existing definition string */
13645 indoid);
13647 defstring);
13649 /*
13650 * Remember if this index is used for the table's replica identity
13651 * or if it is a clustered index, so that ATPostAlterTypeCleanup()
13652 * can queue up commands necessary to restore those properties.
13653 */
13656 }
13657 }
13658 }
13660 /*
13661 * Subroutine for ATExecAlterColumnType: remember that a statistics object
13662 * needs to be rebuilt (which we might already know).
13663 */
13664 static void
13666 {
13667 /*
13668 * This de-duplication check is critical for two independent reasons: we
13669 * mustn't try to recreate the same statistics object twice, and if the
13670 * statistics object depends on more than one column whose type is to be
13671 * altered, we must capture its definition string before applying any of
13672 * the type changes. ruleutils.c will get confused if we ask again later.
13673 */
13675 {
13676 /* OK, capture the statistics object's existing definition string */
13680 stxoid);
13682 defstring);
13683 }
13684 }
13686 /*
13687 * Cleanup after we've finished all the ALTER TYPE or SET EXPRESSION
13688 * operations for a particular relation. We have to drop and recreate all the
13689 * indexes and constraints that depend on the altered columns. We do the
13690 * actual dropping here, but re-creation is managed by adding work queue
13691 * entries to do those steps later.
13692 */
13693 static void
13695 {
13696 ObjectAddress obj;
13701 /*
13702 * Collect all the constraints and indexes to drop so we can process them
13703 * in a single call. That way we don't have to worry about dependencies
13704 * among them.
13705 */
13708 /*
13709 * Re-parse the index and constraint definitions, and attach them to the
13710 * appropriate work queue entries. We do this before dropping because in
13711 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
13712 * lock on the table the constraint is attached to, and we need to get
13713 * that before reparsing/dropping.
13714 *
13715 * We can't rely on the output of deparsing to tell us which relation to
13716 * operate on, because concurrent activity might have made the name
13717 * resolve differently. Instead, we've got to use the OID of the
13718 * constraint or index we're processing to figure out which relation to
13719 * operate on.
13720 */
13723 {
13725 HeapTuple tup;
13726 Form_pg_constraint con;
13727 Oid relid;
13728 Oid confrelid;
13738 else
13739 {
13740 /* must be a domain constraint */
13744 }
13753 /*
13754 * If the constraint is inherited (only), we don't want to inject a
13755 * new definition here; it'll get recreated when ATAddCheckConstraint
13756 * recurses from adding the parent table's constraint. But we had to
13757 * carry the info this far so that we can drop the constraint below.
13758 */
13762 /*
13763 * When rebuilding an FK constraint that references the table we're
13764 * modifying, we might not yet have any lock on the FK's table, so get
13765 * one now. We'll need AccessExclusiveLock for the DROP CONSTRAINT
13766 * step, so there's no value in asking for anything weaker.
13767 */
13774 }
13777 {
13779 Oid relid;
13788 }
13790 /* add dependencies for new statistics */
13793 {
13795 Oid relid;
13804 }
13806 /*
13807 * Queue up command to restore replica identity index marking
13808 */
13810 {
13819 /* do it after indexes and constraints */
13822 }
13824 /*
13825 * Queue up command to restore marking of index used for cluster.
13826 */
13828 {
13834 /* do it after indexes and constraints */
13837 }
13839 /*
13840 * It should be okay to use DROP_RESTRICT here, since nothing else should
13841 * be depending on these objects.
13842 */
13847 /*
13848 * The objects will get recreated during subsequent passes over the work
13849 * queue.
13850 */
13851 }
13853 /*
13854 * Parse the previously-saved definition string for a constraint, index or
13855 * statistics object against the newly-established column data type(s), and
13856 * queue up the resulting command parsetrees for execution.
13857 *
13858 * This might fail if, for example, you have a WHERE clause that uses an
13859 * operator that's not available for the new column type.
13860 */
13861 static void
13864 {
13868 Relation rel;
13870 /*
13871 * We expect that we will get only ALTER TABLE and CREATE INDEX
13872 * statements. Hence, there is no need to pass them through
13873 * parse_analyze_*() or the rewriter, but instead we need to pass them
13874 * through parse_utilcmd.c to make them ready for execution.
13875 */
13879 {
13887 cmd));
13889 {
13895 cmd,
13901 }
13906 cmd));
13907 else
13909 }
13911 /* Caller should already have acquired whatever lock we need. */
13914 /*
13915 * Attach each generated command to the proper place in the work queue.
13916 * Note this could result in creation of entirely new work-queue entries.
13917 *
13918 * Also note that we have to tweak the command subtypes, because it turns
13919 * out that re-creation of indexes and constraints has to act a bit
13920 * differently from initial creation.
13921 */
13923 {
13930 {
13937 /* keep the index's comment */
13945 }
13947 {
13952 {
13956 {
13958 Oid indoid;
13965 /* keep any comment on the index */
13974 /* recreate any comment on the constraint */
13976 AT_PASS_OLD_INDEX,
13977 oldId,
13978 rel,
13979 NIL,
13981 }
13983 {
13987 /* rewriting neither side of a FK */
13996 /* recreate any comment on the constraint */
13998 AT_PASS_OLD_CONSTR,
13999 oldId,
14000 rel,
14001 NIL,
14003 }
14005 {
14006 /*
14007 * The parser will create AT_SetNotNull subcommands for
14008 * columns of PRIMARY KEY indexes/constraints, but we need
14009 * not do anything with them here, because the columns'
14010 * NOT NULL marks will already have been propagated into
14011 * the new table definition.
14012 */
14013 }
14014 else
14017 }
14018 }
14020 {
14024 {
14033 /* recreate any comment on the constraint */
14035 AT_PASS_OLD_CONSTR,
14036 oldId,
14037 NULL,
14040 }
14041 else
14044 }
14046 {
14050 /* keep the statistics object's comment */
14058 }
14059 else
14062 }
14065 }
14067 /*
14068 * Subroutine for ATPostAlterTypeParse() to recreate any existing comment
14069 * for a table or domain constraint that is being rebuilt.
14070 *
14071 * objid is the OID of the constraint.
14072 * Pass "rel" for a table constraint, or "domname" (domain's qualified name
14073 * as a string list) for a domain constraint.
14074 * (We could dig that info, as well as the conname, out of the pg_constraint
14075 * entry; but callers already have them so might as well pass them.)
14076 */
14077 static void
14081 {
14086 /* Look for comment for object wanted, and leave if none */
14091 /* Build CommentStmt node, copying all input data for safety */
14094 {
14100 }
14101 else
14102 {
14107 }
14110 /* Append it to list of commands */
14115 }
14117 /*
14118 * Subroutine for ATPostAlterTypeParse(). Calls out to CheckIndexCompatible()
14119 * for the real analysis, then mutates the IndexStmt based on that verdict.
14120 */
14121 static void
14123 {
14128 {
14131 /* If it's a partitioned index, there is no storage to share. */
14133 {
14137 }
14139 }
14140 }
14142 /*
14143 * Subroutine for ATPostAlterTypeParse().
14144 *
14145 * Stash the old P-F equality operator into the Constraint node, for possible
14146 * use by ATAddForeignKeyConstraint() in determining whether revalidation of
14147 * this constraint can be skipped.
14148 */
14149 static void
14151 {
14152 HeapTuple tup;
14153 Datum adatum;
14167 Anum_pg_constraint_conpfeqop);
14170 /* test follows the one in ri_FetchConstraintInfo() */
14177 /* stash a List of the operator Oids in our Constraint node */
14182 }
14184 /*
14185 * ALTER COLUMN .. OPTIONS ( ... )
14186 *
14187 * Returns the address of the modified column
14188 */
14189 static ObjectAddress
14193 LOCKMODE lockmode)
14194 {
14195 Relation ftrel;
14196 Relation attrel;
14199 HeapTuple tuple;
14200 HeapTuple newtuple;
14205 Datum datum;
14206 Form_pg_foreign_table fttableform;
14207 Form_pg_attribute atttableform;
14208 AttrNumber attnum;
14209 ObjectAddress address;
14214 /* First, determine FDW validator associated to the foreign table. */
14237 /* Prevent them from altering a system attribute */
14246 /* Initialize buffers for new tuple values */
14251 /* Extract the current options */
14253 tuple,
14254 Anum_pg_attribute_attfdwoptions,
14259 /* Transform the options */
14261 datum,
14262 options,
14267 else
14272 /* Everything looks good - update the tuple */
14292 }
14294 /*
14295 * ALTER TABLE OWNER
14296 *
14297 * recursing is true if we are recursing from a table to its indexes,
14298 * sequences, or toast table. We don't allow the ownership of those things to
14299 * be changed separately from the parent table. Also, we can skip permission
14300 * checks (this is necessary not just an optimization, else we'd fail to
14301 * handle toast tables properly).
14302 *
14303 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
14304 * free-standing composite type.
14305 */
14306 void
14308 {
14309 Relation target_rel;
14310 Relation class_rel;
14311 HeapTuple tuple;
14312 Form_pg_class tuple_class;
14314 /*
14315 * Get exclusive lock till end of transaction on the target table. Use
14316 * relation_open so that we can work on indexes and sequences.
14317 */
14320 /* Get its pg_class tuple, too */
14328 /* Can we change the ownership of this tuple? */
14330 {
14336 /* ok to change owner */
14340 {
14341 /*
14342 * Because ALTER INDEX OWNER used to be allowed, and in fact
14343 * is generated by old versions of pg_dump, we give a warning
14344 * and do nothing rather than erroring out. Also, to avoid
14345 * unnecessary chatter while restoring those old dumps, say
14346 * nothing at all if the command would be a no-op anyway.
14347 */
14354 /* quick hack to exit via the no-op path */
14356 }
14370 {
14371 /* if it's an owned sequence, disallow changing it by itself */
14372 Oid tableId;
14373 int32 colId;
14384 }
14393 /* translator: %s is an SQL ALTER command */
14400 /* FALL THRU */
14407 }
14409 /*
14410 * If the new owner is the same as the existing owner, consider the
14411 * command to have succeeded. This is for dump restoration purposes.
14412 */
14414 {
14419 Datum aclDatum;
14421 HeapTuple newtuple;
14423 /* skip permission checks when recursing to index or toast table */
14425 {
14426 /* Superusers can always do it */
14428 {
14430 AclResult aclresult;
14432 /* Otherwise, must be owner of the existing object */
14437 /* Must be able to become new owner */
14440 /* New owner must have CREATE privilege on namespace */
14442 ACL_CREATE);
14446 }
14447 }
14455 /*
14456 * Determine the modified ACL for the new owner. This is only
14457 * necessary when the ACL is non-null.
14458 */
14460 Anum_pg_class_relacl,
14463 {
14468 }
14470 newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
14476 /*
14477 * We must similarly update any per-column ACLs to reflect the new
14478 * owner; for neatness reasons that's split out as a subroutine.
14479 */
14482 newOwnerId);
14484 /*
14485 * Update owner dependency reference, if any. A composite type has
14486 * none, because it's tracked for the pg_type entry instead of here;
14487 * indexes and TOAST tables don't have their own entries either.
14488 */
14494 newOwnerId);
14496 /*
14497 * Also change the ownership of the table's row type, if it has one
14498 */
14502 /*
14503 * If we are operating on a table or materialized view, also change
14504 * the ownership of any indexes and sequences that belong to the
14505 * relation, as well as its toast table (if it has one).
14506 */
14511 {
14515 /* Find all the indexes belonging to this relation */
14518 /* For each index, recursively change its ownership */
14523 }
14525 /* If it has a toast table, recurse to change its ownership */
14530 /* If it has dependent sequences, recurse to change them too */
14532 }
14539 }
14541 /*
14542 * change_owner_fix_column_acls
14543 *
14544 * Helper function for ATExecChangeOwner. Scan the columns of the table
14545 * and fix any non-null column ACLs to reflect the new owner.
14546 */
14547 static void
14549 {
14550 Relation attRelation;
14551 SysScanDesc scan;
14553 HeapTuple attributeTuple;
14557 Anum_pg_attribute_attrelid,
14563 {
14569 Datum aclDatum;
14571 HeapTuple newtuple;
14573 /* Ignore dropped columns */
14578 Anum_pg_attribute_attacl,
14581 /* Null ACLs do not require changes */
14600 }
14603 }
14605 /*
14606 * change_owner_recurse_to_sequences
14607 *
14608 * Helper function for ATExecChangeOwner. Examines pg_depend searching
14609 * for sequences that are dependent on serial columns, and changes their
14610 * ownership.
14611 */
14612 static void
14614 {
14615 Relation depRel;
14616 SysScanDesc scan;
14618 HeapTuple tup;
14620 /*
14621 * SERIAL sequences are those having an auto dependency on one of the
14622 * table's columns (we don't care *which* column, exactly).
14623 */
14627 Anum_pg_depend_refclassid,
14631 Anum_pg_depend_refobjid,
14634 /* we leave refobjsubid unspecified */
14640 {
14642 Relation seqRel;
14644 /* skip dependencies other than auto dependencies on columns */
14651 /* Use relation_open just in case it's an index */
14654 /* skip non-sequence relations */
14656 {
14657 /* No need to keep the lock */
14660 }
14662 /* We don't need to close the sequence while we alter it. */
14665 /* Now we can close it. Keep the lock till end of transaction. */
14667 }
14672 }
14674 /*
14675 * ALTER TABLE CLUSTER ON
14676 *
14677 * The only thing we have to do is to change the indisclustered bits.
14678 *
14679 * Return the address of the new clustering index.
14680 */
14681 static ObjectAddress
14683 {
14684 Oid indexOid;
14685 ObjectAddress address;
14695 /* Check index is valid to cluster on */
14698 /* And do the work */
14705 }
14707 /*
14708 * ALTER TABLE SET WITHOUT CLUSTER
14709 *
14710 * We have to find any indexes on the table that have indisclustered bit
14711 * set and turn it off.
14712 */
14713 static void
14715 {
14717 }
14719 /*
14720 * Preparation phase for SET ACCESS METHOD
14721 *
14722 * Check that the access method exists and determine whether a change is
14723 * actually needed.
14724 */
14725 static void
14727 {
14728 Oid amoid;
14730 /*
14731 * Look up the access method name and check that it differs from the
14732 * table's current AM. If DEFAULT was specified for a partitioned table
14733 * (amname is NULL), set it to InvalidOid to reset the catalogued AM.
14734 */
14739 else
14742 /* if it's a match, phase 3 doesn't need to do anything */
14746 /* Save info for Phase 3 to do the real work */
14750 }
14752 /*
14753 * Special handling of ALTER TABLE SET ACCESS METHOD for relations with no
14754 * storage that have an interest in preserving AM.
14755 *
14756 * Since these have no storage, setting the access method is a catalog only
14757 * operation.
14758 */
14759 static void
14761 {
14762 Relation pg_class;
14763 Oid oldAccessMethodId;
14764 HeapTuple tuple;
14765 Form_pg_class rd_rel;
14768 /*
14769 * Shouldn't be called on relations having storage; these are processed in
14770 * phase 3.
14771 */
14774 /* Get a modifiable copy of the relation's pg_class row. */
14782 /* Update the pg_class row. */
14786 /* Leave if no update required */
14788 {
14792 }
14796 /*
14797 * Update the dependency on the new access method. No dependency is added
14798 * if the new access method is InvalidOid (default case). Be very careful
14799 * that this has to compare the previous value stored in pg_class with the
14800 * new one.
14801 */
14803 {
14804 ObjectAddress relobj,
14805 referenced;
14807 /*
14808 * New access method is defined and there was no dependency
14809 * previously, so record a new one.
14810 */
14814 }
14817 {
14818 /*
14819 * There was an access method defined, and no new one, so just remove
14820 * the existing dependency.
14821 */
14823 AccessMethodRelationId,
14824 DEPENDENCY_NORMAL);
14825 }
14826 else
14827 {
14831 /* Both are valid, so update the dependency */
14833 AccessMethodRelationId,
14835 }
14837 /* make the relam and dependency changes visible */
14844 }
14846 /*
14847 * ALTER TABLE SET TABLESPACE
14848 */
14849 static void
14850 ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, const char *tablespacename, LOCKMODE lockmode)
14851 {
14852 Oid tablespaceId;
14854 /* Check that the tablespace exists */
14857 /* Check permissions except when moving to database's default */
14859 {
14860 AclResult aclresult;
14865 }
14867 /* Save info for Phase 3 to do the real work */
14874 }
14876 /*
14877 * Set, reset, or replace reloptions.
14878 */
14879 static void
14881 LOCKMODE lockmode)
14882 {
14883 Oid relid;
14884 Relation pgclass;
14885 HeapTuple tuple;
14886 HeapTuple newtuple;
14887 Datum datum;
14889 Datum newOptions;
14900 /* Fetch heap tuple */
14907 {
14908 /*
14909 * If we're supposed to replace the reloptions list, we just pretend
14910 * there were none before.
14911 */
14914 }
14915 else
14916 {
14917 /* Get the old reloptions */
14920 }
14922 /* Generate new proposed reloptions (text array) */
14927 /* Validate */
14929 {
14952 }
14954 /* Special-case validation of view options */
14956 {
14963 {
14968 }
14970 /*
14971 * If the check option is specified, look to see if the view is
14972 * actually auto-updatable or not.
14973 */
14975 {
14984 }
14985 }
14987 /*
14988 * All we need do here is update the pg_class row; the new options will be
14989 * propagated into relcaches during post-commit cache inval.
14990 */
14997 else
15013 /* repeat the whole exercise for the toast table, if there's one */
15015 {
15016 Relation toastrel;
15021 /* Fetch heap tuple */
15027 {
15028 /*
15029 * If we're supposed to replace the reloptions list, we just
15030 * pretend there were none before.
15031 */
15034 }
15035 else
15036 {
15037 /* Get the old reloptions */
15040 }
15054 else
15073 }
15076 }
15078 /*
15079 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
15080 * rewriting to be done, so we just want to copy the data as fast as possible.
15081 */
15082 static void
15084 {
15085 Relation rel;
15086 Oid reltoastrelid;
15087 RelFileNumber newrelfilenumber;
15088 RelFileLocator newrlocator;
15092 /*
15093 * Need lock here in case we are recursing to toast table or index
15094 */
15097 /* Check first if relation can be moved to new tablespace */
15099 {
15104 }
15107 /* Fetch the list of indexes on toast relation if necessary */
15109 {
15114 }
15116 /*
15117 * Relfilenumbers are not unique in databases across tablespaces, so we
15118 * need to allocate a new one in the new tablespace.
15119 */
15123 /* Open old and new relation */
15128 /* hand off to AM to actually create new rel storage and copy the data */
15130 {
15132 }
15133 else
15134 {
15137 }
15139 /*
15140 * Update the pg_class row.
15141 *
15142 * NB: This wouldn't work if ATExecSetTableSpace() were allowed to be
15143 * executed on pg_class or its indexes (the above copy wouldn't contain
15144 * the updated pg_class entry), but that's forbidden with
15145 * CheckRelationTableSpaceMove().
15146 */
15155 /* Make sure the reltablespace change is visible */
15158 /* Move associated toast relation and/or indexes, too */
15164 /* Clean up */
15166 }
15168 /*
15169 * Special handling of ALTER TABLE SET TABLESPACE for relations with no
15170 * storage that have an interest in preserving tablespace.
15171 *
15172 * Since these have no storage the tablespace can be updated with a simple
15173 * metadata only operation to update the tablespace.
15174 */
15175 static void
15177 {
15178 /*
15179 * Shouldn't be called on relations having storage; these are processed in
15180 * phase 3.
15181 */
15184 /* check if relation can be moved to its new tablespace */
15186 {
15191 }
15193 /* Update can be done, so change reltablespace */
15198 /* Make sure the reltablespace change is visible */
15200 }
15202 /*
15203 * Alter Table ALL ... SET TABLESPACE
15204 *
15205 * Allows a user to move all objects of some type in a given tablespace in the
15206 * current database to another tablespace. Objects can be chosen based on the
15207 * owner of the object also, to allow users to move only their objects.
15208 * The user must have CREATE rights on the new tablespace, as usual. The main
15209 * permissions handling is done by the lower-level table move function.
15210 *
15211 * All to-be-moved objects are locked first. If NOWAIT is specified and the
15212 * lock can't be acquired then we ereport(ERROR).
15213 */
15214 Oid
15216 {
15220 Relation rel;
15221 TableScanDesc scan;
15222 HeapTuple tuple;
15223 Oid orig_tablespaceoid;
15224 Oid new_tablespaceoid;
15227 /* Ensure we were not asked to move something we can't */
15234 /* Get the orig and new tablespace OIDs */
15238 /* Can't move shared relations in to or out of pg_global */
15239 /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
15246 /*
15247 * Must have CREATE rights on the new tablespace, unless it is the
15248 * database default tablespace (which all users implicitly have CREATE
15249 * rights on).
15250 */
15252 {
15253 AclResult aclresult;
15256 ACL_CREATE);
15260 }
15262 /*
15263 * Now that the checks are done, check if we should set either to
15264 * InvalidOid because it is our database's default tablespace.
15265 */
15272 /* no-op */
15276 /*
15277 * Walk the list of objects in the tablespace and move them. This will
15278 * only find objects in our database, of course.
15279 */
15281 Anum_pg_class_reltablespace,
15288 {
15292 /*
15293 * Do not move objects in pg_catalog as part of this, if an admin
15294 * really wishes to do so, they can issue the individual ALTER
15295 * commands directly.
15296 *
15297 * Also, explicitly avoid any shared tables, temp tables, or TOAST
15298 * (TOAST will be moved with the main table).
15299 */
15306 /* Only move the object type requested */
15317 /* Check if we are only moving objects owned by certain roles */
15321 /*
15322 * Handle permissions-checking here since we are locking the tables
15323 * and also to avoid doing a bunch of work only to fail part-way. Note
15324 * that permissions will also be checked by AlterTableInternal().
15325 *
15326 * Caller must be considered an owner on the table to move it.
15327 */
15339 else
15342 /* Add to our list of objects to move */
15344 }
15356 /* Everything is locked, loop through and move all of the relations. */
15358 {
15368 /* OID is set by AlterTableInternal */
15371 }
15374 }
15376 static void
15378 {
15379 SMgrRelation dstrel;
15381 /*
15382 * Since we copy the file directly without looking at the shared buffers,
15383 * we'd better first flush out any pages of the source relation that are
15384 * in shared buffers. We assume no new changes will be made while we are
15385 * holding exclusive lock on the rel.
15386 */
15389 /*
15390 * Create and copy all forks of the relation, and schedule unlinking of
15391 * old physical files.
15392 *
15393 * NOTE: any conflict in relfilenumber value will be caught in
15394 * RelationCreateStorage().
15395 */
15398 /* copy main fork */
15402 /* copy those extra forks that exist */
15405 {
15407 {
15410 /*
15411 * WAL log creation if the relation is persistent, or this is the
15412 * init fork of an unlogged relation.
15413 */
15420 }
15421 }
15423 /* drop old relation, and close new one */
15426 }
15428 /*
15429 * ALTER TABLE ENABLE/DISABLE TRIGGER
15430 *
15431 * We just pass this off to trigger.c.
15432 */
15433 static void
15436 LOCKMODE lockmode)
15437 {
15440 lockmode);
15444 }
15446 /*
15447 * ALTER TABLE ENABLE/DISABLE RULE
15448 *
15449 * We just pass this off to rewriteDefine.c.
15450 */
15451 static void
15454 {
15459 }
15461 /*
15462 * ALTER TABLE INHERIT
15463 *
15464 * Add a parent to the child's parents. This verifies that all the columns and
15465 * check constraints of the parent appear in the child and that they have the
15466 * same data types and expressions.
15467 */
15468 static void
15470 {
15485 }
15487 /*
15488 * Return the address of the new parent relation.
15489 */
15490 static ObjectAddress
15492 {
15493 Relation parent_rel;
15495 ObjectAddress address;
15498 /*
15499 * A self-exclusive lock is needed here. See the similar case in
15500 * MergeAttributes() for a full explanation.
15501 */
15504 /*
15505 * Must be owner of both parent and child -- child was checked by
15506 * ATSimplePermissions call in ATPrepCmd
15507 */
15510 /* Permanent rels cannot inherit from temporary ones */
15518 /* If parent rel is temp, it must belong to this session */
15525 /* Ditto for the child */
15532 /* Prevent partitioned tables from becoming inheritance parents */
15539 /* Likewise for partitions */
15545 /*
15546 * Prevent circularity by seeing if proposed parent inherits from child.
15547 * (In particular, this disallows making a rel inherit from itself.)
15548 *
15549 * This is not completely bulletproof because of race conditions: in
15550 * multi-level inheritance trees, someone else could concurrently be
15551 * making another inheritance link that closes the loop but does not join
15552 * either of the rels we have locked. Preventing that seems to require
15553 * exclusive locks on the entire inheritance tree, which is a cure worse
15554 * than the disease. find_all_inheritors() will cope with circularity
15555 * anyway, so don't sweat it too much.
15556 *
15557 * We use weakest lock we can on child's children, namely AccessShareLock.
15558 */
15570 /*
15571 * If child_rel has row-level triggers with transition tables, we
15572 * currently don't allow it to become an inheritance child. See also
15573 * prohibitions in ATExecAttachPartition() and CreateTrigger().
15574 */
15581 errdetail("ROW triggers with transition tables are not supported in inheritance hierarchies.")));
15583 /* OK to create inheritance */
15589 /* keep our lock on the parent relation until commit */
15593 }
15595 /*
15596 * CreateInheritance
15597 * Catalog manipulation portion of creating inheritance between a child
15598 * table and a parent table.
15599 *
15600 * Common to ATExecAddInherit() and ATExecAttachPartition().
15601 */
15602 static void
15604 {
15605 Relation catalogRelation;
15606 SysScanDesc scan;
15607 ScanKeyData key;
15608 HeapTuple inheritsTuple;
15609 int32 inhseqno;
15611 /* Note: get RowExclusiveLock because we will write pg_inherits below. */
15614 /*
15615 * Check for duplicates in the list of parents, and determine the highest
15616 * inhseqno already present; we'll use the next one for the new parent.
15617 * Also, if proposed child is a partition, it cannot already be
15618 * inheriting.
15619 *
15620 * Note: we do not reject the case where the child already inherits from
15621 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
15622 */
15624 Anum_pg_inherits_inhrelid,
15630 /* inhseqno sequences start at 1 */
15633 {
15644 }
15647 /* Match up the columns and bump attinhcount as needed */
15650 /* Match up the constraints and bump coninhcount as needed */
15653 /*
15654 * OK, it looks valid. Make the catalog entries that show inheritance.
15655 */
15659 catalogRelation,
15661 RELKIND_PARTITIONED_TABLE);
15663 /* Now we're done with pg_inherits */
15665 }
15667 /*
15668 * Obtain the source-text form of the constraint expression for a check
15669 * constraint, given its pg_constraint tuple
15670 */
15673 {
15674 Form_pg_constraint con;
15676 Datum attr;
15677 Datum expr;
15687 }
15689 /*
15690 * Determine whether two check constraints are functionally equivalent
15691 *
15692 * The test we apply is to see whether they reverse-compile to the same
15693 * source string. This insulates us from issues like whether attributes
15694 * have the same physical column numbers in parent and child relations.
15695 */
15696 static bool
15698 {
15707 else
15709 }
15711 /*
15712 * Check columns in child table match up with columns in parent, and increment
15713 * their attinhcount.
15714 *
15715 * Called by CreateInheritance
15716 *
15717 * Currently all parent columns must be found in child. Missing columns are an
15718 * error. One day we might consider creating new columns like CREATE TABLE
15719 * does. However, that is widely unpopular --- in the common use case of
15720 * partitioned tables it's a foot-gun.
15721 *
15722 * The data type must match exactly. If the parent column is NOT NULL then
15723 * the child must be as well. Defaults are not compared, however.
15724 */
15725 static void
15727 {
15728 Relation attrrel;
15729 TupleDesc parent_desc;
15735 {
15738 HeapTuple tuple;
15740 /* Ignore dropped columns in the parent. */
15744 /* Find same column in child (matching on column name). */
15747 {
15763 /*
15764 * Check child doesn't discard NOT NULL property. (Other
15765 * constraints are checked elsewhere.)
15766 */
15771 parent_attname)));
15773 /*
15774 * Child column must be generated if and only if parent column is.
15775 */
15785 /*
15786 * Regular inheritance children are independent enough not to
15787 * inherit identity columns. But partitions are integral part of
15788 * a partitioned table and inherit identity column.
15789 */
15793 /*
15794 * OK, bump the child column's inheritance count. (If we fail
15795 * later on, this change will just roll back.)
15796 */
15803 /*
15804 * In case of partitions, we must enforce that value of attislocal
15805 * is same in all partitions. (Note: there are only inherited
15806 * attributes in partitions)
15807 */
15809 {
15812 }
15816 }
15817 else
15818 {
15822 }
15823 }
15826 }
15828 /*
15829 * Check constraints in child table match up with constraints in parent,
15830 * and increment their coninhcount.
15831 *
15832 * Constraints that are marked ONLY in the parent are ignored.
15833 *
15834 * Called by CreateInheritance
15835 *
15836 * Currently all constraints in parent must be present in the child. One day we
15837 * may consider adding new constraints like CREATE TABLE does.
15838 *
15839 * XXX This is O(N^2) which may be an issue with tables with hundreds of
15840 * constraints. As long as tables have more like 10 constraints it shouldn't be
15841 * a problem though. Even 100 constraints ought not be the end of the world.
15842 *
15843 * XXX See MergeWithExistingConstraint too if you change this code.
15844 */
15845 static void
15847 {
15848 Relation constraintrel;
15849 SysScanDesc parent_scan;
15850 ScanKeyData parent_key;
15851 HeapTuple parent_tuple;
15856 /* Outer loop scans through the parent's constraint definitions */
15858 Anum_pg_constraint_conrelid,
15865 {
15867 SysScanDesc child_scan;
15868 ScanKeyData child_key;
15869 HeapTuple child_tuple;
15875 /* if the parent's constraint is marked NO INHERIT, it's not inherited */
15879 /* Search for a child constraint matching this one */
15881 Anum_pg_constraint_conrelid,
15888 {
15890 HeapTuple child_copy;
15905 /* If the child constraint is "no inherit" then cannot merge */
15912 /*
15913 * If the child constraint is "not valid" then cannot merge with a
15914 * valid parent constraint
15915 */
15922 /*
15923 * OK, bump the child constraint's inheritance count. (If we fail
15924 * later on, this change will just roll back.)
15925 */
15934 /*
15935 * In case of partitions, an inherited constraint must be
15936 * inherited only once since it cannot have multiple parents and
15937 * it is never considered local.
15938 */
15940 {
15943 }
15950 }
15959 }
15963 }
15965 /*
15966 * ALTER TABLE NO INHERIT
15967 *
15968 * Return value is the address of the relation that is no longer parent.
15969 */
15970 static ObjectAddress
15972 {
15973 ObjectAddress address;
15974 Relation parent_rel;
15981 /*
15982 * AccessShareLock on the parent is probably enough, seeing that DROP
15983 * TABLE doesn't lock parent tables at all. We need some lock since we'll
15984 * be inspecting the parent's schema.
15985 */
15988 /*
15989 * We don't bother to check ownership of the parent table --- ownership of
15990 * the child is presumed enough rights.
15991 */
15993 /* Off to RemoveInheritance() where most of the work happens */
15999 /* keep our lock on the parent relation until commit */
16003 }
16005 /*
16006 * MarkInheritDetached
16007 *
16008 * Set inhdetachpending for a partition, for ATExecDetachPartition
16009 * in concurrent mode. While at it, verify that no other partition is
16010 * already pending detach.
16011 */
16012 static void
16014 {
16015 Relation catalogRelation;
16016 SysScanDesc scan;
16017 ScanKeyData key;
16018 HeapTuple inheritsTuple;
16023 /*
16024 * Find pg_inherits entries by inhparent. (We need to scan them all in
16025 * order to verify that no other partition is pending detach.)
16026 */
16029 Anum_pg_inherits_inhparent,
16036 {
16037 Form_pg_inherits inhForm;
16047 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
16050 {
16051 HeapTuple newtup;
16058 newtup);
16061 /* keep looking, to ensure we catch others pending detach */
16062 }
16063 }
16065 /* Done */
16075 }
16077 /*
16078 * RemoveInheritance
16079 *
16080 * Drop a parent from the child's parents. This just adjusts the attinhcount
16081 * and attislocal of the columns and removes the pg_inherit and pg_depend
16082 * entries. expect_detached is passed down to DeleteInheritsTuple, q.v..
16083 *
16084 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
16085 * up attislocal stays true, which means if a child is ever removed from a
16086 * parent then its columns will never be automatically dropped which may
16087 * surprise. But at least we'll never surprise by dropping columns someone
16088 * isn't expecting to be dropped which would actually mean data loss.
16089 *
16090 * coninhcount and conislocal for inherited constraints are adjusted in
16091 * exactly the same way.
16092 *
16093 * Common to ATExecDropInherit() and ATExecDetachPartition().
16094 */
16095 static void
16097 {
16098 Relation catalogRelation;
16099 SysScanDesc scan;
16101 HeapTuple attributeTuple,
16102 constraintTuple;
16111 expect_detached,
16114 {
16121 else
16127 }
16129 /*
16130 * Search through child columns looking for ones matching parent rel
16131 */
16134 Anum_pg_attribute_attrelid,
16140 {
16143 /* Ignore if dropped or not inherited */
16151 {
16152 /* Decrement inhcount and possibly set islocal to true */
16162 }
16163 }
16167 /*
16168 * Likewise, find inherited check constraints and disinherit them. To do
16169 * this, we first need a list of the names of the parent's check
16170 * constraints. (We cheat a bit by only checking for name matches,
16171 * assuming that the expressions will match.)
16172 */
16175 Anum_pg_constraint_conrelid,
16184 {
16189 }
16193 /* Now scan the child's constraints */
16195 Anum_pg_constraint_conrelid,
16202 {
16211 {
16213 {
16216 }
16217 }
16220 {
16221 /* Decrement inhcount and possibly set islocal to true */
16235 }
16236 }
16242 RelationRelationId,
16246 /*
16247 * Post alter hook of this inherits. Since object_access_hook doesn't take
16248 * multiple object identifiers, we relay oid of parent relation using
16249 * auxiliary_id argument.
16250 */
16254 }
16256 /*
16257 * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE
16258 * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or
16259 * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will
16260 * be TypeRelationId). There's no convenient way to do this, so go trawling
16261 * through pg_depend.
16262 */
16263 static void
16265 DependencyType deptype)
16266 {
16267 Relation catalogRelation;
16268 SysScanDesc scan;
16270 HeapTuple depTuple;
16275 Anum_pg_depend_classid,
16279 Anum_pg_depend_objid,
16283 Anum_pg_depend_objsubid,
16291 {
16299 }
16303 }
16305 /*
16306 * ALTER TABLE OF
16307 *
16308 * Attach a table to a composite type, as though it had been created with CREATE
16309 * TABLE OF. All attname, atttypid, atttypmod and attcollation must match. The
16310 * subject table must not have inheritance parents. These restrictions ensure
16311 * that you cannot create a configuration impossible with CREATE TABLE OF alone.
16312 *
16313 * The address of the type is returned.
16314 */
16315 static ObjectAddress
16317 {
16319 Type typetuple;
16320 Form_pg_type typeform;
16322 Relation inheritsRelation,
16323 relationRelation;
16324 SysScanDesc scan;
16325 ScanKeyData key;
16326 AttrNumber table_attno,
16327 type_attno;
16328 TupleDesc typeTupleDesc,
16329 tableTupleDesc;
16330 ObjectAddress tableobj,
16331 typeobj;
16332 HeapTuple classtuple;
16334 /* Validate the type. */
16340 /* Fail if the table has any inheritance parents. */
16343 Anum_pg_inherits_inhrelid,
16355 /*
16356 * Check the tuple descriptors for compatibility. Unlike inheritance, we
16357 * require that the order also match. However, attnotnull need not match.
16358 */
16363 {
16364 Form_pg_attribute type_attr,
16365 table_attr;
16369 /* Get the next non-dropped type attribute. */
16375 /* Get the next non-dropped table attribute. */
16376 do
16377 {
16382 type_attname)));
16384 table_attno++;
16388 /* Compare name. */
16395 /* Compare type. */
16403 }
16406 /* Any remaining columns at the end of the table had better be dropped. */
16408 {
16417 }
16419 /* If the table was already typed, drop the existing dependency. */
16422 DEPENDENCY_NORMAL);
16424 /* Record a dependency on the new type. */
16433 /* Update pg_class.reloftype */
16449 }
16451 /*
16452 * ALTER TABLE NOT OF
16453 *
16454 * Detach a typed table from its originating type. Just clear reloftype and
16455 * remove the dependency.
16456 */
16457 static void
16459 {
16461 Relation relationRelation;
16462 HeapTuple tuple;
16470 /*
16471 * We don't bother to check ownership of the type --- ownership of the
16472 * table is presumed enough rights. No lock required on the type, either.
16473 */
16476 DEPENDENCY_NORMAL);
16478 /* Clear pg_class.reloftype */
16490 }
16492 /*
16493 * relation_mark_replica_identity: Update a table's replica identity
16494 *
16495 * Iff ri_type = REPLICA_IDENTITY_INDEX, indexOid must be the Oid of a suitable
16496 * index. Otherwise, it must be InvalidOid.
16497 *
16498 * Caller had better hold an exclusive lock on the relation, as the results
16499 * of running two of these concurrently wouldn't be pretty.
16500 */
16501 static void
16504 {
16505 Relation pg_index;
16506 Relation pg_class;
16507 HeapTuple pg_class_tuple;
16508 HeapTuple pg_index_tuple;
16509 Form_pg_class pg_class_form;
16510 Form_pg_index pg_index_form;
16513 /*
16514 * Check whether relreplident has changed, and update it if so.
16515 */
16524 {
16527 }
16531 /*
16532 * Update the per-index indisreplident flags correctly.
16533 */
16536 {
16547 {
16548 /* Set the bit if not already set. */
16550 {
16553 }
16554 }
16555 else
16556 {
16557 /* Unset the bit if set. */
16559 {
16562 }
16563 }
16566 {
16571 /*
16572 * Invalidate the relcache for the table, so that after we commit
16573 * all sessions will refresh the table's replica identity index
16574 * before attempting any UPDATE or DELETE on the table. (If we
16575 * changed the table's pg_class row above, then a relcache inval
16576 * is already queued due to that; but we might not have.)
16577 */
16579 }
16581 }
16584 }
16586 /*
16587 * ALTER TABLE <name> REPLICA IDENTITY ...
16588 */
16589 static void
16591 {
16592 Oid indexOid;
16593 Relation indexRel;
16597 {
16600 }
16602 {
16605 }
16607 {
16610 }
16612 {
16614 }
16615 else
16618 /* Check that the index exists */
16628 /* Check that the index is on the relation we're altering. */
16636 /* The AM must support uniqueness, and the index must in fact be unique. */
16643 /* Deferred indexes are not guaranteed to be always unique. */
16649 /* Expression indexes aren't supported. */
16655 /* Predicate indexes aren't supported. */
16662 /* Check index for nullable columns. */
16664 {
16666 Form_pg_attribute attr;
16668 /*
16669 * Reject any other system columns. (Going forward, we'll disallow
16670 * indexes containing such columns in the first place, but they might
16671 * exist in older branches.)
16672 */
16676 errmsg("index \"%s\" cannot be used as replica identity because column %d is a system column",
16686 }
16688 /* This index is suitable for use as a replica identity. Mark it. */
16692 }
16694 /*
16695 * ALTER TABLE ENABLE/DISABLE ROW LEVEL SECURITY
16696 */
16697 static void
16699 {
16700 Relation pg_class;
16701 Oid relid;
16702 HeapTuple tuple;
16706 /* Pull the record for this relation and update it */
16722 }
16724 /*
16725 * ALTER TABLE FORCE/NO FORCE ROW LEVEL SECURITY
16726 */
16727 static void
16729 {
16730 Relation pg_class;
16731 Oid relid;
16732 HeapTuple tuple;
16751 }
16753 /*
16754 * ALTER FOREIGN TABLE <name> OPTIONS (...)
16755 */
16756 static void
16758 {
16759 Relation ftrel;
16762 HeapTuple tuple;
16767 Datum datum;
16768 Form_pg_foreign_table tableform;
16790 /* Extract the current options */
16792 tuple,
16793 Anum_pg_foreign_table_ftoptions,
16798 /* Transform the options */
16800 datum,
16801 options,
16806 else
16811 /* Everything looks good - update the tuple */
16818 /*
16819 * Invalidate relcache so that all sessions will refresh any cached plans
16820 * that might depend on the old options.
16821 */
16830 }
16832 /*
16833 * ALTER TABLE ALTER COLUMN SET COMPRESSION
16834 *
16835 * Return value is the address of the modified column
16836 */
16837 static ObjectAddress
16841 LOCKMODE lockmode)
16842 {
16843 Relation attrel;
16844 HeapTuple tuple;
16845 Form_pg_attribute atttableform;
16846 AttrNumber attnum;
16849 ObjectAddress address;
16855 /* copy the cache entry so we can scribble on it below */
16863 /* prevent them from altering a system attribute */
16871 /*
16872 * Check that column type is compressible, then get the attribute
16873 * compression method code
16874 */
16877 /* update pg_attribute entry */
16883 attnum);
16885 /*
16886 * Apply the change to indexes as well (only for simple index columns,
16887 * matching behavior of index.c ConstructTupleDescriptor()).
16888 */
16892 lockmode);
16898 /* make changes visible */
16904 }
16907 /*
16908 * Preparation phase for SET LOGGED/UNLOGGED
16909 *
16910 * This verifies that we're not trying to change a temp table. Also,
16911 * existing foreign key constraints are checked to avoid ending up with
16912 * permanent tables referencing unlogged tables.
16913 *
16914 * Return value is false if the operation is a no-op (in which case the
16915 * checks are skipped), otherwise true.
16916 */
16917 static bool
16919 {
16920 Relation pg_constraint;
16921 HeapTuple tuple;
16922 SysScanDesc scan;
16925 /*
16926 * Disallow changing status for a temp table. Also verify whether we can
16927 * get away with doing nothing; in such cases we don't need to run the
16928 * checks below, either.
16929 */
16931 {
16941 /* nothing to do */
16946 /* nothing to do */
16949 }
16951 /*
16952 * Check that the table is not part of any publication when changing to
16953 * UNLOGGED, as UNLOGGED tables can't be published.
16954 */
16963 /*
16964 * Check existing foreign key constraints to preserve the invariant that
16965 * permanent tables cannot reference unlogged ones. Self-referencing
16966 * foreign keys can safely be ignored.
16967 */
16970 /*
16971 * Scan conrelid if changing to permanent, else confrelid. This also
16972 * determines whether a useful index exists.
16973 */
16976 Anum_pg_constraint_confrelid,
16984 {
16988 {
16989 Oid foreignrelid;
16990 Relation foreignrel;
16992 /* the opposite end of what we used as scankey */
16995 /* ignore if self-referencing */
17002 {
17010 }
17011 else
17012 {
17020 }
17023 }
17024 }
17031 }
17033 /*
17034 * Execute ALTER TABLE SET SCHEMA
17035 */
17036 ObjectAddress
17038 {
17039 Relation rel;
17040 Oid relid;
17041 Oid oldNspOid;
17042 Oid nspOid;
17045 ObjectAddress myself;
17049 RangeVarCallbackForAlterRelation,
17053 {
17058 }
17064 /* If it's an owned sequence, disallow moving it by itself. */
17066 {
17067 Oid tableId;
17068 int32 colId;
17078 }
17080 /* Get and lock schema OID and check its permissions. */
17084 /* common checks on switching namespaces */
17096 /* close rel, but keep lock until commit */
17100 }
17102 /*
17103 * The guts of relocating a table or materialized view to another namespace:
17104 * besides moving the relation itself, its dependent objects are relocated to
17105 * the new schema.
17106 */
17107 void
17110 {
17111 Relation classRel;
17115 /* OK, modify the pg_class row and pg_depend entry */
17121 /* Fix the table's row type too, if it has one */
17127 objsMoved);
17129 /* Fix other dependent stuff */
17137 }
17139 /*
17140 * The guts of relocating a relation to another namespace: fix the pg_class
17141 * entry, and the pg_depend entry if any. Caller must already have
17142 * opened and write-locked pg_class.
17143 */
17144 void
17149 {
17150 HeapTuple classTup;
17151 Form_pg_class classForm;
17152 ObjectAddress thisobj;
17166 /*
17167 * If the object has already been moved, don't move it again. If it's
17168 * already in the right place, don't move it, but still fire the object
17169 * access hook.
17170 */
17173 {
17174 /* check for duplicate name (more friendly than unique-index failure) */
17183 /* classTup is a copy, so OK to scribble on */
17188 /* Update dependency on schema if caller said so */
17191 relOid,
17192 NamespaceRelationId,
17193 oldNspOid,
17197 }
17199 {
17203 }
17206 }
17208 /*
17209 * Move all indexes for the specified relation to another namespace.
17210 *
17211 * Note: we assume adequate permission checking was done by the caller,
17212 * and that the caller has a suitable lock on the owning relation.
17213 */
17214 static void
17217 {
17224 {
17226 ObjectAddress thisobj;
17232 /*
17233 * Note: currently, the index will not have its own dependency on the
17234 * namespace, so we don't need to do changeDependencyFor(). There's no
17235 * row type in pg_type, either.
17236 *
17237 * XXX this objsMoved test may be pointless -- surely we have a single
17238 * dependency link from a relation to each index?
17239 */
17241 {
17246 }
17247 }
17250 }
17252 /*
17253 * Move all identity and SERIAL-column sequences of the specified relation to another
17254 * namespace.
17255 *
17256 * Note: we assume adequate permission checking was done by the caller,
17257 * and that the caller has a suitable lock on the owning relation.
17258 */
17259 static void
17262 LOCKMODE lockmode)
17263 {
17264 Relation depRel;
17265 SysScanDesc scan;
17267 HeapTuple tup;
17269 /*
17270 * SERIAL sequences are those having an auto dependency on one of the
17271 * table's columns (we don't care *which* column, exactly).
17272 */
17276 Anum_pg_depend_refclassid,
17280 Anum_pg_depend_refobjid,
17283 /* we leave refobjsubid unspecified */
17289 {
17291 Relation seqRel;
17293 /* skip dependencies other than auto dependencies on columns */
17300 /* Use relation_open just in case it's an index */
17303 /* skip non-sequence relations */
17305 {
17306 /* No need to keep the lock */
17309 }
17311 /* Fix the pg_class and pg_depend entries */
17316 /*
17317 * Sequences used to have entries in pg_type, but no longer do. If we
17318 * ever re-instate that, we'll need to move the pg_type entry to the
17319 * new namespace, too (using AlterTypeNamespaceInternal).
17320 */
17323 /* Now we can close it. Keep the lock till end of transaction. */
17325 }
17330 }
17333 /*
17334 * This code supports
17335 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
17336 *
17337 * Because we only support this for TEMP tables, it's sufficient to remember
17338 * the state in a backend-local data structure.
17339 */
17341 /*
17342 * Register a newly-created relation's ON COMMIT action.
17343 */
17344 void
17346 {
17348 MemoryContext oldcxt;
17350 /*
17351 * We needn't bother registering the relation unless there is an ON COMMIT
17352 * action we need to take.
17353 */
17365 /*
17366 * We use lcons() here so that ON COMMIT actions are processed in reverse
17367 * order of registration. That might not be essential but it seems
17368 * reasonable.
17369 */
17373 }
17375 /*
17376 * Unregister any ON COMMIT action when a relation is deleted.
17377 *
17378 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
17379 */
17380 void
17382 {
17386 {
17390 {
17393 }
17394 }
17395 }
17397 /*
17398 * Perform ON COMMIT actions.
17399 *
17400 * This is invoked just before actually committing, since it's possible
17401 * to encounter errors.
17402 */
17403 void
17405 {
17411 {
17414 /* Ignore entry if already dropped in this xact */
17419 {
17422 /* Do nothing (there shouldn't be such entries, actually) */
17426 /*
17427 * If this transaction hasn't accessed any temporary
17428 * relations, we can skip truncating ON COMMIT DELETE ROWS
17429 * tables, as they must still be empty.
17430 */
17437 }
17438 }
17440 /*
17441 * Truncate relations before dropping so that all dependencies between
17442 * relations are removed after they are worked on. Doing it like this
17443 * might be a waste as it is possible that a relation being truncated will
17444 * be dropped anyway due to its parent being dropped, but this makes the
17445 * code more robust because of not having to re-check that the relation
17446 * exists at truncation time.
17447 */
17452 {
17456 {
17457 ObjectAddress object;
17466 }
17468 /*
17469 * Object deletion might involve toast table access (to clean up
17470 * toasted catalog entries), so ensure we have a valid snapshot.
17471 */
17474 /*
17475 * Since this is an automatic drop, rather than one directly initiated
17476 * by the user, we pass the PERFORM_DELETION_INTERNAL flag.
17477 */
17483 #ifdef USE_ASSERT_CHECKING
17485 /*
17486 * Note that table deletion will call remove_on_commit_action, so the
17487 * entry should get marked as deleted.
17488 */
17490 {
17497 }
17498 #endif
17499 }
17500 }
17502 /*
17503 * Post-commit or post-abort cleanup for ON COMMIT management.
17504 *
17505 * All we do here is remove no-longer-needed OnCommitItem entries.
17506 *
17507 * During commit, remove entries that were deleted during this transaction;
17508 * during abort, remove those created during this transaction.
17509 */
17510 void
17512 {
17516 {
17521 {
17522 /* cur_item must be removed */
17525 }
17526 else
17527 {
17528 /* cur_item must be preserved */
17531 }
17532 }
17533 }
17535 /*
17536 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
17537 *
17538 * During subabort, we can immediately remove entries created during this
17539 * subtransaction. During subcommit, just relabel entries marked during
17540 * this subtransaction as being the parent's responsibility.
17541 */
17542 void
17544 SubTransactionId parentSubid)
17545 {
17549 {
17553 {
17554 /* cur_item must be removed */
17557 }
17558 else
17559 {
17560 /* cur_item must be preserved */
17565 }
17566 }
17567 }
17569 /*
17570 * This is intended as a callback for RangeVarGetRelidExtended(). It allows
17571 * the relation to be locked only if (1) it's a plain or partitioned table,
17572 * materialized view, or TOAST table and (2) the current user is the owner (or
17573 * the superuser) or has been granted MAINTAIN. This meets the
17574 * permission-checking needs of CLUSTER, REINDEX TABLE, and REFRESH
17575 * MATERIALIZED VIEW; we expose it here so that it can be used by all.
17576 */
17577 void
17580 {
17582 AclResult aclresult;
17584 /* Nothing to do if the relation was not found. */
17588 /*
17589 * If the relation does exist, check whether it's an index. But note that
17590 * the relation might have been dropped between the time we did the name
17591 * lookup and now. In that case, there's nothing to do.
17592 */
17602 /* Check permissions */
17608 }
17610 /*
17611 * Callback to RangeVarGetRelidExtended() for TRUNCATE processing.
17612 */
17613 static void
17616 {
17617 HeapTuple tuple;
17619 /* Nothing to do if the relation was not found. */
17631 }
17633 /*
17634 * Callback for RangeVarGetRelidExtended(). Checks that the current user is
17635 * the owner of the relation, or superuser.
17636 */
17637 void
17640 {
17641 HeapTuple tuple;
17643 /* Nothing to do if the relation was not found. */
17663 }
17665 /*
17666 * Common RangeVarGetRelid callback for rename, set schema, and alter table
17667 * processing.
17668 */
17669 static void
17672 {
17674 ObjectType reltype;
17675 HeapTuple tuple;
17676 Form_pg_class classform;
17677 AclResult aclresult;
17686 /* Must own relation. */
17690 /* No system table modifications unless explicitly allowed. */
17697 /*
17698 * Extract the specified relation type from the statement parse tree.
17699 *
17700 * Also, for ALTER .. RENAME, check permissions: the user must (still)
17701 * have CREATE rights on the containing namespace.
17702 */
17704 {
17711 }
17717 else
17718 {
17721 }
17723 /*
17724 * For compatibility with prior releases, we allow ALTER TABLE to be used
17725 * with most other types of relations (but not composite types). We allow
17726 * similar flexibility for ALTER INDEX in the case of RENAME, but not
17727 * otherwise. Otherwise, the user must select the correct form of the
17728 * command for the relation at issue.
17729 */
17756 relkind != RELKIND_PARTITIONED_INDEX
17762 /*
17763 * Don't allow ALTER TABLE on composite types. We want people to use ALTER
17764 * TYPE for that.
17765 */
17770 /* translator: %s is an SQL ALTER command */
17774 /*
17775 * Don't allow ALTER TABLE .. SET SCHEMA on relations that can't be moved
17776 * to a different schema, such as indexes and TOAST tables.
17777 */
17779 {
17791 /* translator: %s is an SQL ALTER command */
17800 }
17803 }
17805 /*
17806 * Transform any expressions present in the partition key
17807 *
17808 * Returns a transformed PartitionSpec.
17809 */
17812 {
17824 /* Check valid number of columns for strategy */
17831 /*
17832 * Create a dummy ParseState and insert the target relation as its sole
17833 * rangetable entry. We need a ParseState for transformExpr.
17834 */
17840 /* take care of any partition expressions */
17842 {
17846 {
17847 /* Copy, to avoid scribbling on the input */
17850 /* Now do parse transformation of the expression */
17852 EXPR_KIND_PARTITION_EXPRESSION);
17854 /* we have to fix its collations too */
17856 }
17859 }
17862 }
17864 /*
17865 * Compute per-partition-column information from a list of PartitionElems.
17866 * Expressions in the PartitionElems must be parse-analyzed already.
17867 */
17868 static void
17869 ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
17871 PartitionStrategy strategy)
17872 {
17875 Oid am_oid;
17879 {
17881 Oid atttype;
17882 Oid attcollation;
17885 {
17886 /* Simple attribute reference */
17887 HeapTuple atttuple;
17888 Form_pg_attribute attform;
17907 /*
17908 * Generated columns cannot work: They are computed after BEFORE
17909 * triggers, but partition routing is done before all triggers.
17910 */
17923 }
17924 else
17925 {
17926 /* Expression */
17934 /*
17935 * The expression must be of a storable type (e.g., not RECORD).
17936 * The test is the same as for whether a table column is of a safe
17937 * type (which is why we needn't check for the non-expression
17938 * case).
17939 */
17945 /*
17946 * Strip any top-level COLLATE clause. This ensures that we treat
17947 * "x COLLATE y" and "(x COLLATE y)" alike.
17948 */
17954 {
17955 /*
17956 * User wrote "(column)" or "(column COLLATE something)".
17957 * Treat it like simple attribute anyway.
17958 */
17960 }
17961 else
17962 {
17969 /*
17970 * transformPartitionSpec() should have already rejected
17971 * subqueries, aggregates, window functions, and SRFs, based
17972 * on the EXPR_KIND_ for partition expressions.
17973 */
17975 /*
17976 * Cannot allow system column references, since that would
17977 * make partition routing impossible: their values won't be
17978 * known yet when we need to do that.
17979 */
17982 {
17984 expr_attrs))
17988 }
17990 /*
17991 * Generated columns cannot work: They are computed after
17992 * BEFORE triggers, but partition routing is done before all
17993 * triggers.
17994 */
17997 {
18008 }
18010 /*
18011 * Preprocess the expression before checking for mutability.
18012 * This is essential for the reasons described in
18013 * contain_mutable_functions_after_planning. However, we call
18014 * expression_planner for ourselves rather than using that
18015 * function, because if constant-folding reduces the
18016 * expression to a constant, we'd like to know that so we can
18017 * complain below.
18018 *
18019 * Like contain_mutable_functions_after_planning, assume that
18020 * expression_planner won't scribble on its input, so this
18021 * won't affect the partexprs entry we saved above.
18022 */
18025 /*
18026 * Partition expressions cannot contain mutable functions,
18027 * because a given row must always map to the same partition
18028 * as long as there is no change in the partition boundary
18029 * structure.
18030 */
18036 /*
18037 * While it is not exactly *wrong* for a partition expression
18038 * to be a constant, it seems better to reject such keys.
18039 */
18044 }
18045 }
18047 /*
18048 * Apply collation override if any
18049 */
18053 /*
18054 * Check we have a collation iff it's a collatable type. The only
18055 * expected failures here are (1) COLLATE applied to a noncollatable
18056 * type, or (2) partition expression had an unresolved collation. But
18057 * we might as well code this to be a complete consistency check.
18058 */
18060 {
18066 }
18067 else
18068 {
18074 }
18078 /*
18079 * Identify the appropriate operator class. For list and range
18080 * partitioning, we use a btree operator class; hash partitioning uses
18081 * a hash operator class.
18082 */
18085 else
18089 {
18093 {
18099 errhint("You must specify a hash operator class or define a default hash operator class for the data type.")));
18100 else
18105 errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
18106 }
18107 }
18108 else
18110 atttype,
18112 am_oid);
18114 attn++;
18115 }
18116 }
18118 /*
18119 * PartConstraintImpliedByRelConstraint
18120 * Do scanrel's existing constraints imply the partition constraint?
18121 *
18122 * "Existing constraints" include its check constraints and column-level
18123 * not-null constraints. partConstraint describes the partition constraint,
18124 * in implicit-AND form.
18125 */
18126 bool
18129 {
18135 {
18139 {
18143 {
18147 i,
18154 /*
18155 * argisrow=false is correct even for a composite column,
18156 * because attnotnull does not represent a SQL-spec IS NOT
18157 * NULL test in such a case, just IS DISTINCT FROM NULL.
18158 */
18162 }
18163 }
18164 }
18167 }
18169 /*
18170 * ConstraintImpliedByRelConstraint
18171 * Do scanrel's existing constraints imply the given constraint?
18172 *
18173 * testConstraint is the constraint to validate. provenConstraint is a
18174 * caller-provided list of conditions which this function may assume
18175 * to be true. Both provenConstraint and testConstraint must be in
18176 * implicit-AND form, must only contain immutable clauses, and must
18177 * contain only Vars with varno = 1.
18178 */
18179 bool
18180 ConstraintImpliedByRelConstraint(Relation scanrel, List *testConstraint, List *provenConstraint)
18181 {
18185 i;
18189 {
18192 /*
18193 * If this constraint hasn't been fully validated yet, we must ignore
18194 * it here.
18195 */
18201 /*
18202 * Run each expression through const-simplification and
18203 * canonicalization. It is necessary, because we will be comparing it
18204 * to similarly-processed partition constraint expressions, and may
18205 * fail to detect valid matches without this.
18206 */
18212 }
18214 /*
18215 * Try to make the proof. Since we are comparing CHECK constraints, we
18216 * need to use weak implication, i.e., we assume existConstraint is
18217 * not-false and try to prove the same for testConstraint.
18218 *
18219 * Note that predicate_implied_by assumes its first argument is known
18220 * immutable. That should always be true for both NOT NULL and partition
18221 * constraints, so we don't test it here.
18222 */
18224 }
18226 /*
18227 * QueuePartitionConstraintValidation
18228 *
18229 * Add an entry to wqueue to have the given partition constraint validated by
18230 * Phase 3, for the given relation, and all its children.
18231 *
18232 * We first verify whether the given constraint is implied by pre-existing
18233 * relation constraints; if it is, there's no need to scan the table to
18234 * validate, so don't queue in that case.
18235 */
18236 static void
18240 {
18241 /*
18242 * Based on the table's existing constraints, determine whether or not we
18243 * may skip scanning the table.
18244 */
18246 {
18251 else
18253 (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
18256 }
18258 /*
18259 * Constraints proved insufficient. For plain relations, queue a
18260 * validation item now; for partitioned tables, recurse to process each
18261 * partition.
18262 */
18264 {
18267 /* Grab a work queue entry. */
18272 }
18274 {
18279 {
18280 Relation part_rel;
18283 /*
18284 * This is the minimum lock we need to prevent deadlocks.
18285 */
18288 /*
18289 * Adjust the constraint for scanrel so that it matches this
18290 * partition's attribute numbers.
18291 */
18292 thisPartConstraint =
18297 thisPartConstraint,
18298 validate_default);
18300 }
18301 }
18302 }
18304 /*
18305 * attachPartitionTable: attach a new partition to the partitioned table
18306 *
18307 * wqueue: the ALTER TABLE work queue; can be NULL when not running as part
18308 * of an ALTER TABLE sequence.
18309 * rel: partitioned relation;
18310 * attachrel: relation of attached partition;
18311 * bound: bounds of attached relation.
18312 */
18313 static void
18314 attachPartitionTable(List **wqueue, Relation rel, Relation attachrel, PartitionBoundSpec *bound)
18315 {
18316 /* OK to create inheritance. Rest of the checks performed there */
18319 /* Update the pg_class entry. */
18322 /* Ensure there exists a correct set of indexes in the partition. */
18325 /* and triggers */
18328 /*
18329 * Clone foreign key constraints. Callee is responsible for setting up
18330 * for phase 3 constraint verification.
18331 */
18333 }
18335 /*
18336 * ALTER TABLE <name> ATTACH PARTITION <partition-name> FOR VALUES
18337 *
18338 * Return the address of the newly attached partition.
18339 */
18340 static ObjectAddress
18343 {
18344 Relation attachrel,
18345 catalog;
18348 SysScanDesc scan;
18349 ScanKeyData skey;
18350 AttrNumber attno;
18352 TupleDesc tupleDesc;
18353 ObjectAddress address;
18355 Oid defaultPartOid;
18361 /*
18362 * We must lock the default partition if one exists, because attaching a
18363 * new partition will change its partition constraint.
18364 */
18365 defaultPartOid =
18372 /*
18373 * XXX I think it'd be a good idea to grab locks on all tables referenced
18374 * by FKs at this point also.
18375 */
18377 /*
18378 * Must be owner of both parent and source table -- parent was checked by
18379 * ATSimplePermissions call in ATPrepCmd
18380 */
18383 /* A partition can only have one parent */
18395 /*
18396 * Table being attached should not already be part of inheritance; either
18397 * as a child table...
18398 */
18401 Anum_pg_inherits_inhrelid,
18412 /* ...or as a parent table (except the case when it is partitioned) */
18414 Anum_pg_inherits_inhparent,
18427 /*
18428 * Prevent circularity by seeing if rel is a partition of attachrel. (In
18429 * particular, this disallows making a rel a partition of itself.)
18430 *
18431 * We do that by checking if rel is a member of the list of attachrel's
18432 * partitions provided the latter is partitioned at all. We want to avoid
18433 * having to construct this list again, so we request the strongest lock
18434 * on all partitions. We need the strongest lock, because we may decide
18435 * to scan them if we find out that the table being attached (or its leaf
18436 * partitions) may contain rows that violate the partition constraint. If
18437 * the table has a constraint that would prevent such rows, which by
18438 * definition is present in all the partitions, we need not scan the
18439 * table, nor its partitions. But we cannot risk a deadlock by taking a
18440 * weaker lock now and the stronger one only when needed.
18441 */
18452 /* If the parent is permanent, so must be all of its partitions. */
18460 /* Temp parent cannot have a partition that is itself not a temp */
18468 /* If the parent is temp, it must belong to this session */
18475 /* Ditto for the partition */
18482 /*
18483 * Check if attachrel has any identity columns or any columns that aren't
18484 * in the parent.
18485 */
18489 {
18493 /* Ignore dropped */
18504 /* Try to find the column in parent (matching on column name) */
18514 }
18516 /*
18517 * If child_rel has row-level triggers with transition tables, we
18518 * currently don't allow it to become a partition. See also prohibitions
18519 * in ATExecAddInherit() and CreateTrigger().
18520 */
18529 /*
18530 * Check that the new partition's bound is valid and does not overlap any
18531 * of existing partitions of the parent - note that it does not return on
18532 * error.
18533 */
18537 /* Attach a new partition to the partitioned table. */
18540 /*
18541 * Generate partition constraint from the partition bound specification.
18542 * If the parent itself is a partition, make sure to include its
18543 * constraint as well.
18544 */
18549 /* Skip validation if there are no constraints to validate. */
18551 {
18552 /*
18553 * Run the partition quals through const-simplification similar to
18554 * check constraints. We skip canonicalize_qual, though, because
18555 * partition quals should be in canonical form already.
18556 */
18557 partConstraint =
18561 /* XXX this sure looks wrong */
18564 /*
18565 * Adjust the generated constraint to match this partition's attribute
18566 * numbers.
18567 */
18569 rel);
18571 /* Validate partition constraints against the table being attached. */
18574 }
18576 /*
18577 * If we're attaching a partition other than the default partition and a
18578 * default one exists, then that partition's partition constraint changes,
18579 * so add an entry to the work queue to validate it, too. (We must not do
18580 * this when the partition being attached is the default one; we already
18581 * did it above!)
18582 */
18584 {
18585 Relation defaultrel;
18590 /* we already hold a lock on the default partition */
18592 defPartConstraint =
18595 /*
18596 * Map the Vars in the constraint expression from rel's attnos to
18597 * defaultrel's.
18598 */
18599 defPartConstraint =
18605 /* keep our lock until commit. */
18607 }
18611 /*
18612 * If the partition we just attached is partitioned itself, invalidate
18613 * relcache for all descendent partitions too to ensure that their
18614 * rd_partcheck expression trees are rebuilt; partitions already locked at
18615 * the beginning of this function.
18616 */
18618 {
18622 {
18624 }
18625 }
18627 /* keep our lock until commit */
18631 }
18633 /*
18634 * AttachPartitionEnsureIndexes
18635 * subroutine for ATExecAttachPartition to create/match indexes
18636 *
18637 * Enforce the indexing rule for partitioned tables during ALTER TABLE / ATTACH
18638 * PARTITION: every partition must have an index attached to each index on the
18639 * partitioned table.
18640 */
18641 static void
18643 {
18649 MemoryContext cxt;
18650 MemoryContext oldcxt;
18654 ALLOCSET_DEFAULT_SIZES);
18662 /* Build arrays of all existing indexes and their IndexInfos */
18664 {
18669 }
18671 /*
18672 * If we're attaching a foreign table, we must fail if any of the indexes
18673 * is a constraint index; otherwise, there's nothing to do here. Do this
18674 * before starting work, to avoid wasting the effort of building a few
18675 * non-unique indexes before coming across a unique one.
18676 */
18678 {
18680 {
18694 }
18697 }
18699 /*
18700 * For each index on the partitioned table, find a matching one in the
18701 * partition-to-be; if one is not found, create one.
18702 */
18704 {
18710 Oid constraintOid;
18712 /*
18713 * Ignore indexes in the partitioned table other than partitioned
18714 * indexes.
18715 */
18717 {
18720 }
18722 /* construct an indexinfo to compare existing indexes against */
18729 /*
18730 * Scan the list of existing indexes in the partition-to-be, and mark
18731 * the first matching, valid, unattached one we find, if any, as
18732 * partition of the parent index. If we find one, we're done.
18733 */
18735 {
18739 /* does this index have a parent? if so, can't use it */
18743 /* If this index is invalid, can't use it */
18752 attmap))
18753 {
18754 /*
18755 * If this index is being created in the parent because of a
18756 * constraint, then the child needs to have a constraint also,
18757 * so look for one. If there is no such constraint, this
18758 * index is no good, so keep looking.
18759 */
18761 {
18762 cldConstrOid =
18764 cldIdxId);
18765 /* no dice */
18769 /* Ensure they're both the same type of constraint */
18773 }
18775 /* bingo. */
18784 }
18785 }
18787 /*
18788 * If no suitable index was found in the partition-to-be, create one
18789 * now.
18790 */
18792 {
18794 Oid conOid;
18801 conOid,
18804 }
18807 }
18809 out:
18810 /* Clean up. */
18815 }
18817 /*
18818 * CloneRowTriggersToPartition
18819 * subroutine for ATExecAttachPartition/DefineRelation to create row
18820 * triggers on partitions
18821 */
18822 static void
18824 {
18825 Relation pg_trigger;
18826 ScanKeyData key;
18827 SysScanDesc scan;
18828 HeapTuple tuple;
18829 MemoryContext perTupCxt;
18841 {
18845 Datum value;
18849 MemoryContext oldcxt;
18851 /*
18852 * Ignore statement-level triggers; those are not cloned.
18853 */
18857 /*
18858 * Don't clone internal triggers, because the constraint cloning code
18859 * will.
18860 */
18864 /*
18865 * Complain if we find an unexpected trigger type.
18866 */
18872 /* Use short-lived context for CREATE TRIGGER */
18875 /*
18876 * If there is a WHEN clause, generate a 'cooked' version of it that's
18877 * appropriate for the partition.
18878 */
18882 {
18888 }
18890 /*
18891 * If there is a column list, transform it to a list of column names.
18892 * Note we don't need to map this list in any way ...
18893 */
18895 {
18899 {
18900 Form_pg_attribute col;
18906 }
18907 }
18909 /* Reconstruct trigger arguments list. */
18911 {
18923 {
18926 }
18927 }
18953 }
18959 }
18961 /*
18962 * ALTER TABLE DETACH PARTITION
18963 *
18964 * Return the address of the relation that is no longer a partition of rel.
18965 *
18966 * If concurrent mode is requested, we run in two transactions. A side-
18967 * effect is that this command cannot run in a multi-part ALTER TABLE.
18968 * Currently, that's enforced by the grammar.
18969 *
18970 * The strategy for concurrency is to first modify the partition's
18971 * pg_inherit catalog row to make it visible to everyone that the
18972 * partition is detached, lock the partition against writes, and commit
18973 * the transaction; anyone who requests the partition descriptor from
18974 * that point onwards has to ignore such a partition. In a second
18975 * transaction, we wait until all transactions that could have seen the
18976 * partition as attached are gone, then we remove the rest of partition
18977 * metadata (pg_inherits and pg_class.relpartbounds).
18978 */
18979 static ObjectAddress
18982 {
18983 Relation partRel;
18984 ObjectAddress address;
18985 Oid defaultPartOid;
18987 /*
18988 * We must lock the default partition, because detaching this partition
18989 * will change its partition constraint.
18990 */
18991 defaultPartOid =
18994 {
18995 /*
18996 * Concurrent detaching when a default partition exists is not
18997 * supported. The main problem is that the default partition
18998 * constraint would change. And there's a definitional problem: what
18999 * should happen to the tuples that are being inserted that belong to
19000 * the partition being detached? Putting them on the partition being
19001 * detached would be wrong, since they'd become "lost" after the
19002 * detaching completes but we cannot put them in the default partition
19003 * either until we alter its partition constraint.
19004 *
19005 * I think we could solve this problem if we effected the constraint
19006 * change before committing the first transaction. But the lock would
19007 * have to remain AEL and it would cause concurrent query planning to
19008 * be blocked, so changing it that way would be even worse.
19009 */
19015 }
19017 /*
19018 * In concurrent mode, the partition is locked with share-update-exclusive
19019 * in the first transaction. This allows concurrent transactions to be
19020 * doing DML to the partition.
19021 */
19023 AccessExclusiveLock);
19025 /*
19026 * Check inheritance conditions and either delete the pg_inherits row (in
19027 * non-concurrent mode) or just set the inhdetachpending flag.
19028 */
19031 else
19034 /*
19035 * Ensure that foreign keys still hold after this detach. This keeps
19036 * locks on the referencing tables, which prevents concurrent transactions
19037 * from adding rows that we wouldn't see. For this to work in concurrent
19038 * mode, it is critical that the partition appears as no longer attached
19039 * for the RI queries as soon as the first transaction commits.
19040 */
19043 /*
19044 * Concurrent mode has to work harder; first we add a new constraint to
19045 * the partition that matches the partition constraint. Then we close our
19046 * existing transaction, and in a new one wait for all processes to catch
19047 * up on the catalog updates we've done so far; at that point we can
19048 * complete the operation.
19049 */
19051 {
19052 Oid partrelid,
19053 parentrelid;
19054 LOCKTAG tag;
19058 /*
19059 * Add a new constraint to the partition being detached, which
19060 * supplants the partition constraint (unless there is one already).
19061 */
19064 /*
19065 * We're almost done now; the only traces that remain are the
19066 * pg_inherits tuple and the partition's relpartbounds. Before we can
19067 * remove those, we need to wait until all transactions that know that
19068 * this is a partition are gone.
19069 */
19071 /*
19072 * Remember relation OIDs to re-acquire them later; and relation names
19073 * too, for error messages if something is dropped in between.
19074 */
19082 /* Invalidate relcache entries for the parent -- must be before close */
19089 /* Make updated catalog entry visible */
19095 /*
19096 * Now wait. This ensures that all queries that were planned
19097 * including the partition are finished before we remove the rest of
19098 * catalog entries. We don't need or indeed want to acquire this
19099 * lock, though -- that would block later queries.
19100 *
19101 * We don't need to concern ourselves with waiting for a lock on the
19102 * partition itself, since we will acquire AccessExclusiveLock below.
19103 */
19107 /*
19108 * Now acquire locks in both relations again. Note they may have been
19109 * removed in the meantime, so care is required.
19110 */
19114 /* If the relations aren't there, something bad happened; bail out */
19116 {
19119 partrelname);
19123 parentrelname)));
19124 }
19131 }
19133 /* Do the final part of detaching */
19138 /* keep our lock until commit */
19142 }
19144 /*
19145 * Second part of ALTER TABLE .. DETACH.
19146 *
19147 * This is separate so that it can be run independently when the second
19148 * transaction of the concurrent algorithm fails (crash or abort).
19149 */
19150 static void
19152 Oid defaultPartOid)
19153 {
19154 Relation classRel;
19161 HeapTuple tuple,
19162 newtuple;
19166 {
19167 /*
19168 * We can remove the pg_inherits row now. (In the non-concurrent case,
19169 * this was already done).
19170 */
19172 }
19174 /* Drop any triggers that were cloned on creation/attach. */
19177 /*
19178 * Detach any foreign keys that are inherited. This includes creating
19179 * additional action triggers.
19180 */
19185 {
19187 HeapTuple contup;
19188 Form_pg_constraint conform;
19190 Oid insertTriggerOid,
19191 updateTriggerOid;
19198 /* consider only the inherited foreign keys */
19201 {
19204 }
19206 /* unset conparentid and adjust conislocal, coninhcount, etc. */
19209 /*
19210 * Also, look up the partition's "check" triggers corresponding to the
19211 * constraint being detached and detach them from the parent triggers.
19212 */
19223 /*
19224 * Make the action triggers on the referenced relation. When this was
19225 * a partition the action triggers pointed to the parent rel (they
19226 * still do), but now we need separate ones of our own.
19227 */
19253 }
19258 /*
19259 * Any sub-constraints that are in the referenced-side of a larger
19260 * constraint have to be removed. This partition is no longer part of the
19261 * key space of the constraint.
19262 */
19264 {
19266 ObjectAddress constraint;
19270 constrOid,
19271 ConstraintRelationId,
19272 DEPENDENCY_INTERNAL);
19277 }
19279 /* Now we can detach indexes */
19282 {
19284 Oid parentidx;
19285 Relation idx;
19286 Oid constrOid;
19287 Oid parentConstrOid;
19298 /*
19299 * If there's a constraint associated with the index, detach it too.
19300 * Careful: it is possible for a constraint index in a partition to be
19301 * the child of a non-constraint index, so verify whether the parent
19302 * index does actually have a constraint.
19303 */
19305 idxid);
19307 parentidx);
19312 }
19314 /* Update pg_class tuple */
19323 /* Clear relpartbound and reset relispartition */
19338 /*
19339 * Drop identity property from all identity columns of partition.
19340 */
19342 {
19348 }
19351 {
19352 /*
19353 * If the relation being detached is the default partition itself,
19354 * remove it from the parent's pg_partitioned_table entry.
19355 *
19356 * If not, we must invalidate default partition's relcache entry, as
19357 * in StorePartitionBound: its partition constraint depends on every
19358 * other partition's partition constraint.
19359 */
19362 else
19364 }
19366 /*
19367 * Invalidate the parent's relcache so that the partition is no longer
19368 * included in its partition descriptor.
19369 */
19372 /*
19373 * If the partition we just detached is partitioned itself, invalidate
19374 * relcache for all descendent partitions too to ensure that their
19375 * rd_partcheck expression trees are rebuilt; must lock partitions before
19376 * doing so, using the same lockmode as what partRel has been locked with
19377 * by the caller.
19378 */
19380 {
19386 {
19388 }
19389 }
19390 }
19392 /*
19393 * ALTER TABLE ... DETACH PARTITION ... FINALIZE
19394 *
19395 * To use when a DETACH PARTITION command previously did not run to
19396 * completion; this completes the detaching process.
19397 */
19398 static ObjectAddress
19400 {
19401 Relation partRel;
19402 ObjectAddress address;
19407 /*
19408 * Wait until existing snapshots are gone. This is important if the
19409 * second transaction of DETACH PARTITION CONCURRENTLY is canceled: the
19410 * user could immediately run DETACH FINALIZE without actually waiting for
19411 * existing transactions. We must not complete the detach action until
19412 * all such queries are complete (otherwise we would present them with an
19413 * inconsistent view of catalogs).
19414 */
19424 }
19426 /*
19427 * DetachAddConstraintIfNeeded
19428 * Subroutine for ATExecDetachPartition. Create a constraint that
19429 * takes the place of the partition constraint, but avoid creating
19430 * a dupe if an constraint already exists which implies the needed
19431 * constraint.
19432 */
19433 static void
19435 {
19441 /*
19442 * Avoid adding a new constraint if the needed constraint is implied by an
19443 * existing constraint
19444 */
19446 {
19452 /* Add constraint on partition, equivalent to the partition constraint */
19462 /* It's a re-add, since it nominally already exists */
19465 }
19466 }
19468 /*
19469 * DropClonedTriggersFromPartition
19470 * subroutine for ATExecDetachPartition to remove any triggers that were
19471 * cloned to the partition when it was created-as-partition or attached.
19472 * This undoes what CloneRowTriggersToPartition did.
19473 */
19474 static void
19476 {
19477 ScanKeyData skey;
19478 SysScanDesc scan;
19479 HeapTuple trigtup;
19480 Relation tgrel;
19485 /*
19486 * Scan pg_trigger to search for all triggers on this rel.
19487 */
19494 {
19496 ObjectAddress trig;
19498 /* Ignore triggers that weren't cloned */
19502 /*
19503 * Ignore internal triggers that are implementation objects of foreign
19504 * keys, because these will be detached when the foreign keys
19505 * themselves are.
19506 */
19510 /*
19511 * This is ugly, but necessary: remove the dependency markings on the
19512 * trigger so that it can be removed.
19513 */
19515 TriggerRelationId,
19516 DEPENDENCY_PARTITION_PRI);
19518 RelationRelationId,
19519 DEPENDENCY_PARTITION_SEC);
19521 /* remember this trigger to remove it below */
19524 }
19526 /* make the dependency removal visible to the deletion below */
19530 /* done */
19534 }
19536 /*
19537 * Before acquiring lock on an index, acquire the same lock on the owning
19538 * table.
19539 */
19540 struct AttachIndexCallbackState
19541 {
19542 Oid partitionOid;
19543 Oid parentTblOid;
19545 };
19547 static void
19550 {
19552 Form_pg_class classform;
19553 HeapTuple tuple;
19558 {
19561 }
19563 /*
19564 * If we previously locked some other heap, and the name we're looking up
19565 * no longer refers to an index on that relation, release the now-useless
19566 * lock. XXX maybe we should do *after* we verify whether the index does
19567 * not actually belong to the same relation ...
19568 */
19570 {
19573 }
19575 /* Didn't find a relation, so no need for locking or permission checks. */
19590 /*
19591 * Since we need only examine the heap's tupledesc, an access share lock
19592 * on it (preventing any DDL) is sufficient.
19593 */
19596 }
19598 /*
19599 * ALTER INDEX i1 ATTACH PARTITION i2
19600 */
19601 static ObjectAddress
19603 {
19604 Relation partIdx;
19605 Relation partTbl;
19606 Relation parentTbl;
19607 ObjectAddress address;
19608 Oid partIdxId;
19609 Oid currParent;
19612 /*
19613 * We need to obtain lock on the index 'name' to modify it, but we also
19614 * need to read its owning table's tuple descriptor -- so we need to lock
19615 * both. To avoid deadlocks, obtain lock on the table before doing so on
19616 * the index. Furthermore, we need to examine the parent table of the
19617 * partition, so lock that one too.
19618 */
19622 partIdxId =
19624 RangeVarCallbackForAttachIndex,
19626 /* Not there? */
19632 /* no deadlock risk: RangeVarGetRelidExtended already acquired the lock */
19635 /* we already hold locks on both tables, so this is safe: */
19641 /* Silently do nothing if already in the right state */
19645 {
19651 PartitionDesc partDesc;
19652 Oid constraintOid,
19655 /*
19656 * If this partition already has an index attached, refuse the
19657 * operation.
19658 */
19670 /* Make sure it indexes a partition of the other index's table */
19674 {
19676 {
19679 }
19680 }
19691 /* Ensure the indexes are compatible */
19702 attmap))
19710 /*
19711 * If there is a constraint in the parent, make sure there is one in
19712 * the child too.
19713 */
19718 {
19720 partIdxId);
19727 errdetail("The index \"%s\" belongs to a constraint in table \"%s\" but no constraint exists for index \"%s\".",
19731 }
19733 /* All good -- do it */
19742 }
19745 /* keep these locks till commit */
19750 }
19752 /*
19753 * Verify whether the given partition already contains an index attached
19754 * to the given partitioned index. If so, raise an error.
19755 */
19756 static void
19758 {
19759 Oid existingIdx;
19771 }
19773 /*
19774 * Verify whether the set of attached partition indexes to a parent index on
19775 * a partitioned table is complete. If it is, mark the parent index valid.
19776 *
19777 * This should be called each time a partition index is attached.
19778 */
19779 static void
19781 {
19782 Relation inheritsRel;
19783 SysScanDesc scan;
19784 ScanKeyData key;
19786 HeapTuple inhTup;
19791 /*
19792 * Scan pg_inherits for this parent index. Count each valid index we find
19793 * (verifying the pg_index entry for each), and if we reach the total
19794 * amount we expect, we can mark this parent index as valid.
19795 */
19803 {
19805 HeapTuple indTup;
19806 Form_pg_index indexForm;
19816 }
19818 /* Done with pg_inherits */
19822 /*
19823 * If we found as many inherited indexes as the partitioned table has
19824 * partitions, we're good; update pg_index to set indisvalid.
19825 */
19827 {
19828 Relation idxRel;
19829 HeapTuple indTup;
19830 Form_pg_index indexForm;
19847 }
19849 /*
19850 * If this index is in turn a partition of a larger index, validating it
19851 * might cause the parent to become valid also. Try that.
19852 */
19854 {
19855 Oid parentIdxId,
19856 parentTblId;
19857 Relation parentIdx,
19858 parentTbl;
19860 /* make sure we see the validation we just did */
19873 }
19874 }
19876 /*
19877 * Return an OID list of constraints that reference the given relation
19878 * that are marked as having a parent constraints.
19879 */
19882 {
19883 Relation pg_constraint;
19884 HeapTuple tuple;
19885 SysScanDesc scan;
19889 /*
19890 * If no indexes, or no columns are referenceable by FKs, we can avoid the
19891 * scan.
19892 */
19895 INDEX_ATTR_BITMAP_KEY)))
19898 /* Search for constraints referencing this table */
19907 /* XXX This is a seqscan, as we don't have a usable index */
19910 {
19913 /*
19914 * We only need to process constraints that are part of larger ones.
19915 */
19920 }
19926 }
19928 /*
19929 * During DETACH PARTITION, verify that any foreign keys pointing to the
19930 * partitioned table would not become invalid. An error is raised if any
19931 * referenced values exist.
19932 */
19933 static void
19935 {
19942 {
19944 HeapTuple tuple;
19945 Form_pg_constraint constrForm;
19946 Relation rel;
19957 /* prevent data changes into the referencing table until commit */
19969 /* we needn't fill in remaining fields */
19976 }
19977 }
19979 /*
19980 * resolve column compression specification to compression method.
19981 */
19982 static char
19984 {
19990 /*
19991 * To specify a nondefault method, the column data type must be toastable.
19992 * Note this says nothing about whether the column's attstorage setting
19993 * permits compression; we intentionally allow attstorage and
19994 * attcompression to be independent. But with a non-toastable type,
19995 * attstorage could not be set to a value that would permit compression.
19996 *
19997 * We don't actually need to enforce this, since nothing bad would happen
19998 * if attcompression were non-default; it would never be consulted. But
19999 * it seems more user-friendly to complain about a certainly-useless
20000 * attempt to set the property.
20001 */
20015 }
20017 /*
20018 * resolve column storage specification
20019 */
20020 static char
20022 {
20035 else
20039 storagemode)));
20041 /*
20042 * safety check: do not allow toasted storage modes unless column datatype
20043 * is TOAST-aware.
20044 */
20052 }
20054 /*
20055 * Struct with context of new partition for inserting rows from split partition
20056 */
20058 {
20060 * (NULL for DEFAULT partition) */
20067 /*
20068 * createSplitPartitionContext: create context for partition and fill it
20069 */
20072 {
20078 /*
20079 * Prepare a BulkInsertState for table_tuple_insert. The FSM is empty, so
20080 * don't bother using it.
20081 */
20084 /* Create tuple slot for new partition. */
20090 }
20092 /*
20093 * deleteSplitPartitionContext: delete context for partition
20094 */
20095 static void
20097 {
20104 }
20106 /*
20107 * moveSplitTableRows: scan split partition (splitRel) of partitioned table
20108 * (rel) and move rows into new partitions.
20109 *
20110 * New partitions description:
20111 * partlist: list of pointers to SinglePartitionSpec structures.
20112 * newPartRels: list of Relations.
20113 * defaultPartOid: oid of DEFAULT partition, for table rel.
20114 */
20115 static void
20116 moveSplitTableRows(Relation rel, Relation splitRel, List *partlist, List *newPartRels, Oid defaultPartOid)
20117 {
20118 /* The FSM is empty, so don't bother using it. */
20120 CommandId mycid;
20126 TableScanDesc scan;
20127 Snapshot snapshot;
20128 MemoryContext oldCxt;
20140 {
20146 {
20147 /* We should not create constraint for detached DEFAULT partition. */
20149 }
20150 else
20151 {
20154 /* Build expression execution states for partition check quals. */
20156 partConstraint =
20159 /* Make boolean expression for ExecCheck(). */
20162 /*
20163 * Map the vars in the constraint expression from rel's attnos to
20164 * splitRel's.
20165 */
20172 }
20174 /* Store partition context into list. */
20176 }
20178 /*
20179 * Create partition context for DEFAULT partition. We can insert values
20180 * into this partition in case spaces with values between new partitions.
20181 */
20183 {
20184 /* Indicate that we allocate context for old DEFAULT partition */
20186 defaultPartCtx = createSplitPartitionContext(table_open(defaultPartOid, AccessExclusiveLock));
20187 }
20191 /* Create necessary tuple slot. */
20195 /*
20196 * Map computing for moving attributes of split partition to new partition
20197 * (for first new partition, but other new partitions can use the same
20198 * map).
20199 */
20204 /* Scan through the rows. */
20208 /*
20209 * Switch to per-tuple memory context and reset it for each tuple
20210 * produced, so we don't leak memory.
20211 */
20215 {
20219 /* Extract data from old tuple. */
20224 /* Search partition for current slot srcslot. */
20226 {
20231 {
20234 }
20236 }
20238 {
20239 /* Use DEFAULT partition if it exists. */
20242 else
20247 }
20250 {
20251 /* Need to use map to copy attributes. */
20253 }
20254 else
20255 {
20256 /* Copy attributes directly. */
20267 }
20269 /* Write the tuple out to the new relation. */
20276 }
20293 /* Need to close table and free buffers for DEFAULT partition. */
20295 {
20299 /* Keep the lock until commit. */
20301 }
20302 }
20304 /*
20305 * createPartitionTable: create table for a new partition with given name
20306 * (newPartName) like table (modelRel)
20307 *
20308 * Emulates command: CREATE [TEMP] TABLE <newPartName> (LIKE <modelRel's name>
20309 * INCLUDING ALL EXCLUDING INDEXES EXCLUDING IDENTITY EXCLUDING STATISTICS)
20310 *
20311 * Also, this function sets the new partition access method same as parent
20312 * table access methods (similarly to CREATE TABLE ... PARTITION OF). It
20313 * checks that parent and child tables have compatible persistence.
20314 *
20315 * Function returns the created relation (locked in AccessExclusiveLock mode).
20316 */
20317 static Relation
20320 {
20324 Relation newRel;
20326 /* If existing rel is temp, it must belong to this session */
20333 /* New partition should have the same persistence as modelRel */
20351 /*
20352 * Indexes will be inherited on "attach new partitions" stage, after data
20353 * moving. We also don't copy the extended statistics for consistency
20354 * with CREATE TABLE PARTITION OF.
20355 */
20361 /* Need to make a wrapper PlannedStmt. */
20372 PROCESS_UTILITY_SUBCOMMAND,
20373 NULL,
20374 NULL,
20375 None_Receiver,
20376 NULL);
20378 /*
20379 * Open the new partition with no lock, because we already have
20380 * AccessExclusiveLock placed there after creation.
20381 */
20384 /*
20385 * We intended to create the partition with the same persistence as the
20386 * parent table, but we still need to recheck because that might be
20387 * affected by the search_path. If the parent is permanent, so must be
20388 * all of its partitions.
20389 */
20397 /* Permanent rels cannot be partitions belonging to temporary parent */
20406 }
20408 /*
20409 * ALTER TABLE <name> SPLIT PARTITION <partition-name> INTO <partition-list>
20410 */
20411 static void
20414 {
20415 Relation splitRel;
20416 Oid splitRelOid;
20418 Oid namespaceId;
20424 ObjectAddress object;
20425 Oid defaultPartOid;
20429 /*
20430 * We are going to detach and remove this partition: need to use exclusive
20431 * lock for preventing DML-queries to the partition.
20432 */
20437 /* Check descriptions of new partitions. */
20439 {
20440 Oid existing_relid;
20445 /*
20446 * Look up the namespace in which we are supposed to create the
20447 * partition, check we have permission to create there, lock it
20448 * against concurrent drop, and mark stmt->relation as
20449 * RELPERSISTENCE_TEMP if a temporary namespace is selected.
20450 */
20452 namespaceId =
20455 /*
20456 * This would fail later on anyway if the relation already exists. But
20457 * by catching it here we can emit a nicer error message.
20458 */
20461 /* One new partition can have the same name as split partition. */
20467 }
20469 /* Detach split partition. */
20471 /* Do the final part of detaching. */
20474 /*
20475 * If new partition has the same name as split partition then we should
20476 * rename split partition for reusing name.
20477 */
20479 {
20480 /*
20481 * We must bump the command counter to make the split partition tuple
20482 * visible for renaming.
20483 */
20485 /* Rename partition. */
20489 /*
20490 * We must bump the command counter to make the split partition tuple
20491 * visible after renaming.
20492 */
20494 }
20496 /* Create new partitions (like split partition), without indexes. */
20498 {
20500 Relation newPartRel;
20504 }
20506 /* Copy data from split partition to new partitions. */
20508 /* Keep the lock until commit. */
20511 /* Attach new partitions to partitioned table. */
20513 {
20517 /*
20518 * wqueue = NULL: verification for each cloned constraint is not
20519 * needed.
20520 */
20522 /* Keep the lock until commit. */
20524 }
20526 /* Drop split partition. */
20530 /* Probably DROP_CASCADE is not needed. */
20532 }
20534 /*
20535 * moveMergedTablesRows: scan partitions to be merged (mergingPartitionsList)
20536 * of the partitioned table (rel) and move rows into the new partition
20537 * (newPartRel).
20538 */
20539 static void
20541 Relation newPartRel)
20542 {
20543 CommandId mycid;
20545 /* The FSM is empty, so don't bother using it. */
20553 /* Prepare a BulkInsertState for table_tuple_insert. */
20556 /* Create necessary tuple slot. */
20562 {
20566 TableScanDesc scan;
20567 Snapshot snapshot;
20569 /* Create tuple slot for new partition. */
20573 /*
20574 * Map computing for moving attributes of merged partition to new
20575 * partition.
20576 */
20580 /* Scan through the rows. */
20585 {
20588 /* Extract data from old tuple. */
20592 {
20593 /* Need to use map to copy attributes. */
20595 }
20596 else
20597 {
20598 /* Copy attributes directly. */
20609 }
20611 /* Write the tuple out to the new relation. */
20616 }
20625 }
20631 }
20633 /*
20634 * ALTER TABLE <name> MERGE PARTITIONS <partition-list> INTO <partition-name>
20635 */
20636 static void
20639 {
20640 Relation newPartRel;
20643 Oid defaultPartOid;
20644 Oid namespaceId;
20645 Oid existingRelid;
20647 /*
20648 * Lock all merged partitions, check them and create list with partitions
20649 * contexts.
20650 */
20652 {
20654 Relation mergingPartition;
20656 /*
20657 * We are going to detach and remove this partition: need to use
20658 * exclusive lock for preventing DML-queries to the partition.
20659 */
20662 /* Store a next merging partition into the list. */
20664 mergingPartition);
20665 }
20667 /*
20668 * Look up the namespace in which we are supposed to create the partition,
20669 * check we have permission to create there, lock it against concurrent
20670 * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
20671 * namespace is selected.
20672 */
20674 namespaceId =
20677 /*
20678 * Check if this name is already taken. This helps us to detect the
20679 * situation when one of the merging partitions has the same name as the
20680 * new partition. Otherwise, this would fail later on anyway but catching
20681 * this here allows us to emit a nicer error message.
20682 */
20686 {
20690 {
20692 {
20695 }
20696 }
20699 {
20700 /*
20701 * The new partition has the same name as one of merging
20702 * partitions.
20703 */
20706 /* Generate temporary name. */
20709 /*
20710 * Rename the existing partition with a temporary name, leaving it
20711 * free for the new partition. We don't need to care about this
20712 * in the future because we're going to eventually drop the
20713 * existing partition anyway.
20714 */
20718 /*
20719 * We must bump the command counter to make the new partition
20720 * tuple visible for rename.
20721 */
20723 }
20724 else
20725 {
20729 }
20730 }
20732 /* Detach all merged partitions. */
20733 defaultPartOid =
20736 {
20739 /* Remove the pg_inherits row first. */
20741 /* Do the final part of detaching. */
20743 }
20745 /* Create table for new partition, use partitioned table as model. */
20748 /* Copy data from merged partitions to new partition. */
20751 /* Drop the current partitions before attaching the new one. */
20753 {
20754 ObjectAddress object;
20757 /* Get relation id before table_close() call. */
20762 /* Keep the lock until commit. */
20766 }
20769 /*
20770 * Attach a new partition to the partitioned table. wqueue = NULL:
20771 * verification for each cloned constraint is not needed.
20772 */
20775 /* Keep the lock until commit. */
20777 }