| blob | de0d911b468a001af1adddff16d6b781cf4bc7b9 |
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 */
111 /*
112 * ON COMMIT action list
113 */
115 {
119 /*
120 * If this entry was created during the current transaction,
121 * creating_subid is the ID of the creating subxact; if created in a prior
122 * transaction, creating_subid is zero. If deleted during the current
123 * transaction, deleting_subid is the ID of the deleting subxact; if no
124 * deletion request is pending, deleting_subid is zero.
125 */
126 SubTransactionId creating_subid;
127 SubTransactionId deleting_subid;
133 /*
134 * State information for ALTER TABLE
135 *
136 * The pending-work queue for an ALTER TABLE is a List of AlteredTableInfo
137 * structs, one for each table modified by the operation (the named table
138 * plus any child tables that are affected). We save lists of subcommands
139 * to apply to this table (possibly modified by parse transformation steps);
140 * these lists will be executed in Phase 2. If a Phase 3 step is needed,
141 * necessary information is stored in the constraints and newvals lists.
142 *
143 * Phase 2 is divided into multiple passes; subcommands are executed in
144 * a pass determined by subcommand type.
145 */
148 {
157 /* We could support a RENAME COLUMN pass here, but not currently used */
166 #define AT_NUM_PASSES (AT_PASS_MISC + 1)
169 {
170 /* Information saved before any work commences: */
175 /*
176 * Transiently set during Phase 2, normally set to NULL.
177 *
178 * ATRewriteCatalogs sets this when it starts, and closes when ATExecCmd
179 * returns control. This can be exploited by ATExecCmd subroutines to
180 * close/reopen across transaction boundaries.
181 */
182 Relation rel;
184 /* Information saved by Phase 1 for Phase 2: */
186 /* Information saved by Phases 1/2 for Phase 3: */
194 * if above is true */
199 /* true, if validating default due to some other attach/detach */
201 /* Objects to rebuild after completing ALTER TYPE operations */
212 /* Struct describing one new constraint to check in Phase 3 scan */
213 /* Note: new not-null constraints are handled elsewhere */
215 {
226 /*
227 * Struct describing one new column value that needs to be computed during
228 * Phase 3 copy (this could be either a new column with a non-null default, or
229 * a column that we're changing the type of). Columns without such an entry
230 * are just copied from the old table during ATRewriteTable. Note that the
231 * expr is an expression over *old* table values, except when is_generated
232 * is true; then it is an expression over columns of the *new* tuple.
233 */
235 {
242 /*
243 * Error-reporting support for RemoveRelations
244 */
245 struct dropmsgstrings
246 {
253 };
257 ERRCODE_UNDEFINED_TABLE,
263 ERRCODE_UNDEFINED_TABLE,
269 ERRCODE_UNDEFINED_TABLE,
275 ERRCODE_UNDEFINED_TABLE,
281 ERRCODE_UNDEFINED_OBJECT,
287 ERRCODE_UNDEFINED_OBJECT,
293 ERRCODE_UNDEFINED_OBJECT,
299 ERRCODE_UNDEFINED_TABLE,
305 ERRCODE_UNDEFINED_OBJECT,
311 };
313 /* communication between RemoveRelations and RangeVarCallbackForDropRelation */
314 struct DropRelationCallbackState
315 {
316 /* These fields are set by RemoveRelations: */
318 LOCKMODE heap_lockmode;
319 /* These fields are state to track which subsidiary locks are held: */
320 Oid heapOid;
321 Oid partParentOid;
322 /* These fields are passed back by RangeVarCallbackForDropRelation: */
325 };
327 /* Alter table target-type flags for ATSimplePermissions */
328 #define ATT_TABLE 0x0001
329 #define ATT_VIEW 0x0002
330 #define ATT_MATVIEW 0x0004
331 #define ATT_INDEX 0x0008
332 #define ATT_COMPOSITE_TYPE 0x0010
333 #define ATT_FOREIGN_TABLE 0x0020
334 #define ATT_PARTITIONED_INDEX 0x0040
335 #define ATT_SEQUENCE 0x0080
337 /*
338 * ForeignTruncateInfo
339 *
340 * Information related to truncation of foreign tables. This is used for
341 * the elements in a hash table. It uses the server OID as lookup key,
342 * and includes a per-server list of all foreign tables involved in the
343 * truncation.
344 */
346 {
347 Oid serverid;
351 /*
352 * Partition tables are expected to be dropped when the parent partitioned
353 * table gets dropped. Hence for partitioning we use AUTO dependency.
354 * Otherwise, for regular inheritance use NORMAL dependency.
355 */
356 #define child_dependency_type(child_is_partition) \
357 ((child_is_partition) ? DEPENDENCY_AUTO : DEPENDENCY_NORMAL)
368 static void MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef);
369 static ColumnDef *MergeInheritedAttribute(List *inh_columns, int exist_attno, const ColumnDef *newdef);
370 static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel, bool ispartition);
382 LOCKMODE lockmode);
387 LOCKMODE lockmode);
421 AlterTablePass cur_pass,
434 LOCKMODE lockmode,
437 DropBehavior behavior);
451 LOCKMODE lockmode);
471 static ObjectAddress ATExecDropIdentity(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode,
473 static ObjectAddress ATExecSetExpression(AlteredTableInfo *tab, Relation rel, const char *colName,
475 static void ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode);
476 static ObjectAddress ATExecDropExpression(Relation rel, const char *colName, bool missing_ok, LOCKMODE lockmode);
487 DropBehavior behavior,
500 LOCKMODE lockmode);
508 LOCKMODE lockmode);
512 LOCKMODE lockmode);
534 Relation partitionRel);
537 Relation partRel);
540 Oid indexOid,
545 Oid indexOid,
549 Oid partRelid,
553 Oid parentInsTrigger,
554 Oid parentUpdTrigger,
555 Relation trigrel);
571 LOCKMODE lockmode);
586 LOCKMODE lockmode);
602 LOCKMODE lockmode);
612 AlterTableType operation,
613 LOCKMODE lockmode);
616 LOCKMODE lockmode);
623 DependencyType deptype);
641 static void ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
643 PartitionStrategy strategy);
669 Relation partitionTbl);
682 /* ----------------------------------------------------------------
683 * DefineRelation
684 * Creates a new relation.
685 *
686 * stmt carries parsetree information from an ordinary CREATE TABLE statement.
687 * The other arguments are used to extend the behavior for other cases:
688 * relkind: relkind to assign to the new relation
689 * ownerId: if not InvalidOid, use this as the new relation's owner.
690 * typaddress: if not null, it's set to the pg_type entry's address.
691 * queryString: for error reporting
692 *
693 * Note that permissions checks are done against current user regardless of
694 * ownerId. A nonzero ownerId is used when someone is creating a relation
695 * "on behalf of" someone else, so we still want to see that the current user
696 * has permissions to do it.
697 *
698 * If successful, returns the address of the new relation.
699 * ----------------------------------------------------------------
700 */
701 ObjectAddress
704 {
706 Oid namespaceId;
707 Oid relationId;
708 Oid tablespaceId;
709 Relation rel;
710 TupleDesc descriptor;
717 Datum reloptions;
719 AttrNumber attnum;
722 Oid ofTypeId;
723 ObjectAddress address;
724 LOCKMODE parentLockmode;
727 /*
728 * Truncate relname to appropriate length (probably a waste of time, as
729 * parser should have done this already).
730 */
733 /*
734 * Check consistency of arguments
735 */
743 {
749 }
750 else
753 /*
754 * Look up the namespace in which we are supposed to create the relation,
755 * check we have permission to create there, lock it against concurrent
756 * drop, and mark stmt->relation as RELPERSISTENCE_TEMP if a temporary
757 * namespace is selected.
758 */
759 namespaceId =
762 /*
763 * Security check: disallow creating temp tables from security-restricted
764 * code. This is needed because calling code might not expect untrusted
765 * tables to appear in pg_temp at the front of its search path.
766 */
773 /*
774 * Determine the lockmode to use when scanning parents. A self-exclusive
775 * lock is needed here.
776 *
777 * For regular inheritance, if two backends attempt to add children to the
778 * same parent simultaneously, and that parent has no pre-existing
779 * children, then both will attempt to update the parent's relhassubclass
780 * field, leading to a "tuple concurrently updated" error. Also, this
781 * interlocks against a concurrent ANALYZE on the parent table, which
782 * might otherwise be attempting to clear the parent's relhassubclass
783 * field, if its previous children were recently dropped.
784 *
785 * If the child table is a partition, then we instead grab an exclusive
786 * lock on the parent because its partition descriptor will be changed by
787 * addition of the new partition.
788 */
790 ShareUpdateExclusiveLock);
792 /* Determine the list of OIDs of the parents. */
795 {
797 Oid parentOid;
801 /*
802 * Reject duplications in the list of parents.
803 */
811 }
813 /*
814 * Select tablespace to use: an explicitly indicated one, or (in the case
815 * of a partitioned table) the parent's, if it has one.
816 */
818 {
825 }
827 {
830 }
831 else
834 /* still nothing? use the default */
837 partitioned);
839 /* Check permissions except when using database's default */
841 {
842 AclResult aclresult;
845 ACL_CREATE);
849 }
851 /* In all cases disallow placing user relations in pg_global */
857 /* Identify user ID that will own the table */
861 /*
862 * Parse and validate reloptions, if any.
863 */
868 {
877 }
880 {
881 AclResult aclresult;
888 }
889 else
892 /*
893 * Look up inheritance ancestors and generate relation schema, including
894 * inherited attributes. (Note that stmt->tableElts is destructively
895 * modified by MergeAttributes.)
896 */
903 /*
904 * Create a tuple descriptor from the relation schema. Note that this
905 * deals with column names, types, and in-descriptor NOT NULL flags, but
906 * not default values, NOT NULL or CHECK constraints; we handle those
907 * below.
908 */
911 /*
912 * Find columns with default values and prepare for insertion of the
913 * defaults. Pre-cooked (that is, inherited) defaults go into a list of
914 * CookedConstraint structs that we'll pass to heap_create_with_catalog,
915 * while raw defaults go into a list of RawColumnDefault structs that will
916 * be processed by AddRelationNewConstraints. (We can't deal with raw
917 * expressions until we can do transformExpr.)
918 *
919 * We can set the atthasdef flags now in the tuple descriptor; this just
920 * saves StoreAttrDefault from having to do an immediate update of the
921 * pg_attribute rows.
922 */
928 {
930 Form_pg_attribute attr;
932 attnum++;
936 {
948 }
950 {
965 }
966 }
968 /*
969 * For relations with table AM and partitioned tables, select access
970 * method to use: an explicitly indicated one, or (in the case of a
971 * partitioned table) the parent's, if it has one.
972 */
974 {
977 }
979 {
981 {
984 }
988 }
990 /*
991 * Create the relation. Inherited defaults and constraints are passed in
992 * for immediate handling --- since they don't need parsing, they can be
993 * stored immediately.
994 */
996 namespaceId,
997 tablespaceId,
998 InvalidOid,
999 InvalidOid,
1000 ofTypeId,
1001 ownerId,
1002 accessMethodId,
1003 descriptor,
1005 old_constraints),
1006 relkind,
1011 reloptions,
1013 allowSystemTableMods,
1015 InvalidOid,
1016 typaddress);
1018 /*
1019 * We must bump the command counter to make the newly-created relation
1020 * tuple visible for opening.
1021 */
1024 /*
1025 * Open the new relation and acquire exclusive lock on it. This isn't
1026 * really necessary for locking out other backends (since they can't see
1027 * the new rel anyway until we commit), but it keeps the lock manager from
1028 * complaining about deadlock risks.
1029 */
1032 /*
1033 * Now add any newly specified column default and generation expressions
1034 * to the new relation. These are passed to us in the form of raw
1035 * parsetrees; we need to transform them to executable expression trees
1036 * before they can be added. The most convenient way to do that is to
1037 * apply the parser's transformExpr routine, but transformExpr doesn't
1038 * work unless we have a pre-existing relation. So, the transformation has
1039 * to be postponed to this final step of CREATE TABLE.
1040 *
1041 * This needs to be before processing the partitioning clauses because
1042 * those could refer to generated columns.
1043 */
1048 /*
1049 * Make column generation expressions visible for use by partitioning.
1050 */
1053 /* Process and store partition bound, if any. */
1055 {
1059 defaultPartOid;
1060 Relation parent,
1064 /* Already have strong enough lock on the parent */
1067 /*
1068 * We are going to try to validate the partition bound specification
1069 * against the partition key of parentRel, so it better have one.
1070 */
1077 /*
1078 * The partition constraint of the default partition depends on the
1079 * partition bounds of every other partition. It is possible that
1080 * another backend might be about to execute a query on the default
1081 * partition table, and that the query relies on previously cached
1082 * default partition constraints. We must therefore take a table lock
1083 * strong enough to prevent all queries on the default partition from
1084 * proceeding until we commit and send out a shared-cache-inval notice
1085 * that will make them update their index lists.
1086 *
1087 * Order of locking: The relation being added won't be visible to
1088 * other backends until it is committed, hence here in
1089 * DefineRelation() the order of locking the default partition and the
1090 * relation being added does not matter. But at all other places we
1091 * need to lock the default relation before we lock the relation being
1092 * added or removed i.e. we should take the lock in same order at all
1093 * the places such that lock parent, lock default partition and then
1094 * lock the partition so as to avoid a deadlock.
1095 */
1096 defaultPartOid =
1102 /* Transform the bound values */
1106 /*
1107 * Add an nsitem containing this relation, so that transformExpr
1108 * called on partition bound expressions is able to report errors
1109 * using a proper context.
1110 */
1117 /*
1118 * Check first that the new partition's bound is valid and does not
1119 * overlap with any of existing partitions of the parent.
1120 */
1123 /*
1124 * If the default partition exists, its partition constraints will
1125 * change after the addition of this new partition such that it won't
1126 * allow any row that qualifies for this new partition. So, check that
1127 * the existing data in the default partition satisfies the constraint
1128 * as it will exist after adding this partition.
1129 */
1131 {
1133 /* Keep the lock until commit. */
1135 }
1137 /* Update the pg_class entry. */
1141 }
1143 /* Store inheritance information for new rel. */
1146 /*
1147 * Process the partitioning specification (if any) and store the partition
1148 * key information into the catalog.
1149 */
1151 {
1164 /* Protect fixed-size arrays here and in executor */
1169 PARTITION_MAX_KEYS)));
1171 /*
1172 * We need to transform the raw parsetrees corresponding to partition
1173 * expressions into executable expression trees. Like column defaults
1174 * and CHECK constraints, we could not have done the transformation
1175 * earlier.
1176 */
1184 partexprs,
1187 /* make it all visible */
1189 }
1191 /*
1192 * If we're creating a partition, create now all the indexes, triggers,
1193 * FKs defined in the parent.
1194 *
1195 * We can't do it earlier, because DefineIndex wants to know the partition
1196 * key which we just stored.
1197 */
1199 {
1201 Relation parent;
1205 /* Already have strong enough lock on the parent */
1209 /*
1210 * For each index in the parent table, create one in the partition
1211 */
1213 {
1217 Oid constraintOid;
1220 {
1228 else
1229 {
1232 }
1233 }
1238 idxstmt =
1242 idxstmt,
1243 InvalidOid,
1245 constraintOid,
1250 }
1254 /*
1255 * If there are any row-level triggers, clone them to the new
1256 * partition.
1257 */
1261 /*
1262 * And foreign keys too. Note that because we're freshly creating the
1263 * table, there is no need to verify these new constraints.
1264 */
1268 }
1270 /*
1271 * Now add any newly specified CHECK constraints to the new relation. Same
1272 * as for defaults above, but these need to come after partitioning is set
1273 * up.
1274 */
1279 /*
1280 * Finally, merge the not-null constraints that are declared directly with
1281 * those that come from parent relations (making sure to count inheritance
1282 * appropriately for each), create them, and set the attnotnull flag on
1283 * columns that don't yet have it.
1284 */
1286 old_notnulls);
1292 /*
1293 * Clean up. We keep lock on new relation (although it shouldn't be
1294 * visible to anyone else anyway, until commit).
1295 */
1299 }
1301 /*
1302 * BuildDescForRelation
1303 *
1304 * Given a list of ColumnDef nodes, build a TupleDesc.
1305 *
1306 * Note: tdtypeid will need to be filled in later on.
1307 */
1308 TupleDesc
1310 {
1312 AttrNumber attnum;
1314 TupleDesc desc;
1317 Oid atttypid;
1318 int32 atttypmod;
1319 Oid attcollation;
1322 /*
1323 * allocate a new tuple descriptor
1324 */
1332 {
1334 AclResult aclresult;
1335 Form_pg_attribute att;
1337 /*
1338 * for each entry in the list, get the name and type information from
1339 * the list and have TupleDescInitEntry fill in the attribute
1340 * information we need.
1341 */
1342 attnum++;
1362 attname)));
1368 /* Override TupleDescInitEntry's settings as requested */
1371 /* Fill in additional stuff not handled by TupleDescInitEntry */
1383 }
1386 {
1397 }
1398 else
1399 {
1401 }
1404 }
1406 /*
1407 * Emit the right error or warning message for a "DROP" command issued on a
1408 * non-existent relation
1409 */
1410 static void
1412 {
1417 {
1419 {
1423 }
1424 else
1425 {
1429 }
1431 }
1434 {
1436 {
1438 {
1442 }
1443 else
1444 {
1447 }
1448 }
1449 }
1452 }
1454 /*
1455 * Emit the right error message for a "DROP" command issued on a
1456 * relation of the wrong type
1457 */
1458 static void
1460 {
1472 /* wrongkind could be something we don't have in our table... */
1478 }
1480 /*
1481 * RemoveRelations
1482 * Implements DROP TABLE, DROP INDEX, DROP SEQUENCE, DROP VIEW,
1483 * DROP MATERIALIZED VIEW, DROP FOREIGN TABLE
1484 */
1485 void
1487 {
1494 /* DROP CONCURRENTLY uses a weaker lock, and has some restrictions */
1496 {
1497 /*
1498 * Note that for temporary relations this lock may get upgraded later
1499 * on, but as no other session can access a temporary relation, this
1500 * is actually fine.
1501 */
1512 }
1514 /*
1515 * First we identify all the relations, then we delete them in a single
1516 * performMultipleDeletions() call. This is to avoid unwanted DROP
1517 * RESTRICT errors if one of the relations depends on another.
1518 */
1520 /* Determine required relkind */
1522 {
1552 }
1554 /* Lock and validate each relation; build a list of object addresses */
1558 {
1560 Oid relOid;
1561 ObjectAddress obj;
1564 /*
1565 * These next few steps are a great deal like relation_openrv, but we
1566 * don't bother building a relcache entry since we don't need it.
1567 *
1568 * Check for shared-cache-inval messages before trying to access the
1569 * relation. This is needed to cover the case where the name
1570 * identifies a rel that has been dropped and recreated since the
1571 * start of our transaction: if we don't flush the old syscache entry,
1572 * then we'll latch onto that entry and suffer an error later.
1573 */
1576 /* Look up the appropriate relation using namespace search. */
1580 /* We must initialize these fields to show that no locks are held: */
1585 RangeVarCallbackForDropRelation,
1588 /* Not there? */
1590 {
1593 }
1595 /*
1596 * Decide if concurrent mode needs to be used here or not. The
1597 * callback retrieved the rel's persistence for us.
1598 */
1601 {
1605 }
1607 /*
1608 * Concurrent index drop cannot be used with partitioned indexes,
1609 * either.
1610 */
1618 /*
1619 * If we're told to drop a partitioned index, we must acquire lock on
1620 * all the children of its parent partitioned table before proceeding.
1621 * Otherwise we'd try to lock the child index partitions before their
1622 * tables, leading to potential deadlock against other sessions that
1623 * will lock those objects in the other order.
1624 */
1628 NULL);
1630 /* OK, we're ready to delete this one */
1636 }
1641 }
1643 /*
1644 * Before acquiring a table lock, check whether we have sufficient rights.
1645 * In the case of DROP INDEX, also try to lock the table before the index.
1646 * Also, if the table to be dropped is a partition, we try to lock the parent
1647 * first.
1648 */
1649 static void
1652 {
1653 HeapTuple tuple;
1657 Form_pg_class classform;
1658 LOCKMODE heap_lockmode;
1664 /*
1665 * If we previously locked some other index's heap, and the name we're
1666 * looking up no longer refers to that relation, release the now-useless
1667 * lock.
1668 */
1670 {
1673 }
1675 /*
1676 * Similarly, if we previously locked some other partition's heap, and the
1677 * name we're looking up no longer refers to that relation, release the
1678 * now-useless lock.
1679 */
1681 {
1684 }
1686 /* Didn't find a relation, so no need for locking or permission checks. */
1696 /* Pass back some data to save lookups in RemoveRelations */
1700 /*
1701 * Both RELKIND_RELATION and RELKIND_PARTITIONED_TABLE are OBJECT_TABLE,
1702 * but RemoveRelations() can only pass one relkind for a given relation.
1703 * It chooses RELKIND_RELATION for both regular and partitioned tables.
1704 * That means we must be careful before giving the wrong type error when
1705 * the relation is RELKIND_PARTITIONED_TABLE. An equivalent problem
1706 * exists with indexes.
1707 */
1712 else
1719 /* Allow DROP to either table owner or schema owner */
1726 /*
1727 * Check the case of a system index that might have been invalidated by a
1728 * failed concurrent process and allow its drop. For the time being, this
1729 * only concerns indexes of toast relations that became invalid during a
1730 * REINDEX CONCURRENTLY process.
1731 */
1733 {
1734 HeapTuple locTuple;
1735 Form_pg_index indexform;
1740 {
1743 }
1749 /* Mark object as being an invalid index of system catalogs */
1752 }
1754 /* In the case of an invalid index, it is fine to bypass this check */
1763 /*
1764 * In DROP INDEX, attempt to acquire lock on the parent table before
1765 * locking the index. index_drop() will need this anyway, and since
1766 * regular queries lock tables before their indexes, we risk deadlock if
1767 * we do it the other way around. No error if we don't find a pg_index
1768 * entry, though --- the relation may have been dropped. Note that this
1769 * code will execute for either plain or partitioned indexes.
1770 */
1773 {
1777 }
1779 /*
1780 * Similarly, if the relation is a partition, we must acquire lock on its
1781 * parent before locking the partition. That's because queries lock the
1782 * parent before its partitions, so we risk deadlock if we do it the other
1783 * way around.
1784 */
1786 {
1790 }
1791 }
1793 /*
1794 * ExecuteTruncate
1795 * Executes a TRUNCATE command.
1796 *
1797 * This is a multi-relation truncate. We first open and grab exclusive
1798 * lock on all relations involved, checking permissions and otherwise
1799 * verifying that the relation is OK for truncation. Note that if relations
1800 * are foreign tables, at this stage, we have not yet checked that their
1801 * foreign data in external data sources are OK for truncation. These are
1802 * checked when foreign data are actually truncated later. In CASCADE mode,
1803 * relations having FK references to the targeted relations are automatically
1804 * added to the group; in RESTRICT mode, we check that all FK references are
1805 * internal to the group that's being truncated. Finally all the relations
1806 * are truncated and reindexed.
1807 */
1808 void
1810 {
1816 /*
1817 * Open, exclusive-lock, and check all the explicitly-specified relations
1818 */
1820 {
1822 Relation rel;
1824 Oid myrelid;
1829 NULL);
1831 /* don't throw error for "TRUNCATE foo, foo" */
1835 /* open the relation, we already hold a lock on it */
1838 /*
1839 * RangeVarGetRelidExtended() has done most checks with its callback,
1840 * but other checks with the now-opened Relation remain.
1841 */
1847 /* Log this relation only if needed for logical decoding */
1852 {
1859 {
1865 /* find_all_inheritors already got lock */
1868 /*
1869 * It is possible that the parent table has children that are
1870 * temp tables of other backends. We cannot safely access
1871 * such tables (because of buffering issues), and the best
1872 * thing to do is to silently ignore them. Note that this
1873 * check is the same as one of the checks done in
1874 * truncate_check_activity() called below, still it is kept
1875 * here for simplicity.
1876 */
1878 {
1881 }
1883 /*
1884 * Inherited TRUNCATE commands perform access permission
1885 * checks on the parent table only. So we skip checking the
1886 * children's permissions and don't call
1887 * truncate_check_perms() here.
1888 */
1895 /* Log this relation only if needed for logical decoding */
1898 }
1899 }
1904 errhint("Do not specify the ONLY keyword, or use TRUNCATE ONLY on the partitions directly.")));
1905 }
1910 /* And close the rels */
1912 {
1916 }
1917 }
1919 /*
1920 * ExecuteTruncateGuts
1921 *
1922 * Internal implementation of TRUNCATE. This is called by the actual TRUNCATE
1923 * command (see above) as well as replication subscribers that execute a
1924 * replicated TRUNCATE action.
1925 *
1926 * explicit_rels is the list of Relations to truncate that the command
1927 * specified. relids is the list of Oids corresponding to explicit_rels.
1928 * relids_logged is the list of Oids (a subset of relids) that require
1929 * WAL-logging. This is all a bit redundant, but the existing callers have
1930 * this information handy in this form.
1931 */
1932 void
1938 {
1945 SubTransactionId mySubid;
1949 /*
1950 * Check the explicitly-specified relations.
1951 *
1952 * In CASCADE mode, suck in all referencing relations as well. This
1953 * requires multiple iterations to find indirectly-dependent relations. At
1954 * each phase, we need to exclusive-lock new rels before looking for their
1955 * dependencies, else we might miss something. Also, we check each rel as
1956 * soon as we open it, to avoid a faux pas such as holding lock for a long
1957 * time on a rel we have no permissions for.
1958 */
1961 {
1963 {
1971 {
1973 Relation rel;
1985 /* Log this relation only if needed for logical decoding */
1988 }
1989 }
1990 }
1992 /*
1993 * Check foreign key references. In CASCADE mode, this should be
1994 * unnecessary since we just pulled in all the references; but as a
1995 * cross-check, do it anyway if in an Assert-enabled build.
1996 */
1997 #ifdef USE_ASSERT_CHECKING
1999 #else
2002 #endif
2004 /*
2005 * If we are asked to restart sequences, find all the sequences, lock them
2006 * (we need AccessExclusiveLock for ResetSequence), and check permissions.
2007 * We want to do this early since it's pointless to do all the truncation
2008 * work only to fail on sequence permissions.
2009 */
2011 {
2013 {
2019 {
2021 Relation seq_rel;
2025 /* This check must match AlterSequence! */
2033 }
2034 }
2035 }
2037 /* Prepare to catch AFTER triggers. */
2040 /*
2041 * To fire triggers, we'll need an EState as well as a ResultRelInfo for
2042 * each relation. We don't need to call ExecOpenIndices, though.
2043 *
2044 * We put the ResultRelInfos in the es_opened_result_relations list, even
2045 * though we don't have a range table and don't populate the
2046 * es_result_relations array. That's a bit bogus, but it's enough to make
2047 * ExecGetTriggerResultRel() find them.
2048 */
2054 {
2058 rel,
2060 NULL,
2064 resultRelInfo++;
2065 }
2067 /*
2068 * Process all BEFORE STATEMENT TRUNCATE triggers before we begin
2069 * truncating (this is because one of them might throw an error). Also, if
2070 * we were to allow them to prevent statement execution, that would need
2071 * to be handled here.
2072 */
2075 {
2076 UserContext ucxt;
2084 resultRelInfo++;
2085 }
2087 /*
2088 * OK, truncate each table.
2089 */
2093 {
2096 /* Skip partitioned tables as there is nothing to do */
2100 /*
2101 * Build the lists of foreign tables belonging to each foreign server
2102 * and pass each list to the foreign data wrapper's callback function,
2103 * so that each server can truncate its all foreign tables in bulk.
2104 * Each list is saved as a single entry in a hash table that uses the
2105 * server OID as lookup key.
2106 */
2108 {
2113 /* First time through, initialize hashtable for foreign tables */
2115 {
2116 HASHCTL hctl;
2127 }
2129 /* Find or create cached entry for the foreign table */
2134 /*
2135 * Save the foreign table in the entry of the server that the
2136 * foreign table belongs to.
2137 */
2140 }
2142 /*
2143 * Normally, we need a transaction-safe truncation here. However, if
2144 * the table was either created in the current (sub)transaction or has
2145 * a new relfilenumber in the current (sub)transaction, then we can
2146 * just truncate it in-place, because a rollback would cause the whole
2147 * table or the current physical file to be thrown away anyway.
2148 */
2151 {
2152 /* Immediate, non-rollbackable truncation is OK */
2154 }
2155 else
2156 {
2157 Oid heap_relid;
2158 Oid toast_relid;
2161 /*
2162 * This effectively deletes all rows in the table, and may be done
2163 * in a serializable transaction. In that case we must record a
2164 * rw-conflict in to this transaction from each transaction
2165 * holding a predicate lock on the table.
2166 */
2169 /*
2170 * Need the full transaction-safe pushups.
2171 *
2172 * Create a new empty storage file for the relation, and assign it
2173 * as the relfilenumber value. The old storage file is scheduled
2174 * for deletion at commit.
2175 */
2180 /*
2181 * The same for the toast table, if any.
2182 */
2185 {
2187 AccessExclusiveLock);
2192 }
2194 /*
2195 * Reconstruct the indexes to match, and we're done.
2196 */
2199 }
2202 }
2204 /* Now go through the hash table, and truncate foreign tables */
2206 {
2208 HASH_SEQ_STATUS seq;
2213 {
2215 {
2218 /* truncate_check_rel() has checked that already */
2222 behavior,
2223 restart_seqs);
2224 }
2225 }
2227 {
2229 }
2231 }
2233 /*
2234 * Restart owned sequences if we were asked to.
2235 */
2237 {
2241 }
2243 /*
2244 * Write a WAL record to allow this set of actions to be logically
2245 * decoded.
2246 *
2247 * Assemble an array of relids so we can write a single WAL record for the
2248 * whole action.
2249 */
2251 {
2252 xl_heap_truncate xlrec;
2255 /* should only get here if wal_level >= logical */
2277 }
2279 /*
2280 * Process all AFTER STATEMENT TRUNCATE triggers.
2281 */
2284 {
2285 UserContext ucxt;
2293 resultRelInfo++;
2294 }
2296 /* Handle queued AFTER triggers */
2299 /* We can clean up the EState now */
2302 /*
2303 * Close any rels opened by CASCADE (can't do this while EState still
2304 * holds refs)
2305 */
2308 {
2312 }
2313 }
2315 /*
2316 * Check that a given relation is safe to truncate. Subroutine for
2317 * ExecuteTruncate() and RangeVarCallbackForTruncate().
2318 */
2319 static void
2321 {
2324 /*
2325 * Only allow truncate on regular tables, foreign tables using foreign
2326 * data wrappers supporting TRUNCATE and partitioned tables (although, the
2327 * latter are only being included here for the following checks; no
2328 * physical truncation will occur in their case.).
2329 */
2331 {
2339 relname)));
2340 }
2347 /*
2348 * Most system catalogs can't be truncated at all, or at least not unless
2349 * allow_system_table_mods=on. As an exception, however, we allow
2350 * pg_largeobject to be truncated as part of pg_upgrade, because we need
2351 * to change its relfilenode to match the old cluster, and allowing a
2352 * TRUNCATE command to be executed is the easiest way of doing that.
2353 */
2359 relname)));
2362 }
2364 /*
2365 * Check that current user has the permission to truncate given relation.
2366 */
2367 static void
2369 {
2371 AclResult aclresult;
2373 /* Permissions checks */
2377 relname);
2378 }
2380 /*
2381 * Set of extra sanity checks to check if a given relation is safe to
2382 * truncate. This is split with truncate_check_rel() as
2383 * RangeVarCallbackForTruncate() cannot open a Relation yet.
2384 */
2385 static void
2387 {
2388 /*
2389 * Don't allow truncate on temp tables of other backends ... their local
2390 * buffer manager is not going to cope.
2391 */
2397 /*
2398 * Also check for active uses of the relation in the current transaction,
2399 * including open scans and pending AFTER trigger events.
2400 */
2402 }
2404 /*
2405 * storage_name
2406 * returns the name corresponding to a typstorage/attstorage enum value
2407 */
2410 {
2412 {
2423 }
2424 }
2426 /*----------
2427 * MergeAttributes
2428 * Returns new schema given initial schema and superclasses.
2429 *
2430 * Input arguments:
2431 * 'columns' is the column/attribute definition for the table. (It's a list
2432 * of ColumnDef's.) It is destructively changed.
2433 * 'supers' is a list of OIDs of parent relations, already locked by caller.
2434 * 'relpersistence' is the persistence type of the table.
2435 * 'is_partition' tells if the table is a partition.
2436 *
2437 * Output arguments:
2438 * 'supconstr' receives a list of constraints belonging to the parents,
2439 * updated as necessary to be valid for the child.
2440 * 'supnotnulls' receives a list of CookedConstraints that corresponds to
2441 * constraints coming from inheritance parents.
2442 *
2443 * Return value:
2444 * Completed schema list.
2445 *
2446 * Notes:
2447 * The order in which the attributes are inherited is very important.
2448 * Intuitively, the inherited attributes should come first. If a table
2449 * inherits from multiple parents, the order of those attributes are
2450 * according to the order of the parents specified in CREATE TABLE.
2451 *
2452 * Here's an example:
2453 *
2454 * create table person (name text, age int4, location point);
2455 * create table emp (salary int4, manager text) inherits(person);
2456 * create table student (gpa float8) inherits (person);
2457 * create table stud_emp (percent int4) inherits (emp, student);
2458 *
2459 * The order of the attributes of stud_emp is:
2460 *
2461 * person {1:name, 2:age, 3:location}
2462 * / \
2463 * {6:gpa} student emp {4:salary, 5:manager}
2464 * \ /
2465 * stud_emp {7:percent}
2466 *
2467 * If the same attribute name appears multiple times, then it appears
2468 * in the result table in the proper location for its first appearance.
2469 *
2470 * Constraints (including not-null constraints) for the child table
2471 * are the union of all relevant constraints, from both the child schema
2472 * and parent tables. In addition, in legacy inheritance, each column that
2473 * appears in a primary key in any of the parents also gets a NOT NULL
2474 * constraint (partitioning doesn't need this, because the PK itself gets
2475 * inherited.)
2476 *
2477 * The default value for a child column is defined as:
2478 * (1) If the child schema specifies a default, that value is used.
2479 * (2) If neither the child nor any parent specifies a default, then
2480 * the column will not have a default.
2481 * (3) If conflicting defaults are inherited from different parents
2482 * (and not overridden by the child), an error is raised.
2483 * (4) Otherwise the inherited default is used.
2484 *
2485 * Note that the default-value infrastructure is used for generated
2486 * columns' expressions too, so most of the preceding paragraph applies
2487 * to generation expressions too. We insist that a child column be
2488 * generated if and only if its parent(s) are, but it need not have
2489 * the same generation expression.
2490 *----------
2491 */
2495 {
2505 /*
2506 * Check for and reject tables with too many columns. We perform this
2507 * check relatively early for two reasons: (a) we don't run the risk of
2508 * overflowing an AttrNumber in subsequent code (b) an O(n^2) algorithm is
2509 * okay if we're processing <= 1600 columns, but could take minutes to
2510 * execute if the user attempts to create a table with hundreds of
2511 * thousands of columns.
2512 *
2513 * Note that we also need to check that we do not exceed this figure after
2514 * including columns from inherited relations.
2515 */
2520 MaxHeapAttributeNumber)));
2522 /*
2523 * Check for duplicate names in the explicit list of attributes.
2524 *
2525 * Although we might consider merging such entries in the same way that we
2526 * handle name conflicts for inherited attributes, it seems to make more
2527 * sense to assume such conflicts are errors.
2528 *
2529 * We don't use foreach() here because we have two nested loops over the
2530 * columns list, with possible element deletions in the inner one. If we
2531 * used foreach_delete_current() it could only fix up the state of one of
2532 * the loops, so it seems cleaner to use looping over list indexes for
2533 * both loops. Note that any deletion will happen beyond where the outer
2534 * loop is, so its index never needs adjustment.
2535 */
2537 {
2541 {
2542 /*
2543 * Typed table column option that does not belong to a column from
2544 * the type. This works because the columns from the type come
2545 * first in the list. (We omit this check for partition column
2546 * lists; those are processed separately below.)
2547 */
2552 }
2554 /* restpos scans all entries beyond coldef; incr is in loop body */
2556 {
2560 {
2562 {
2563 /*
2564 * merge the column options into the column from the type
2565 */
2572 }
2573 else
2578 }
2579 else
2580 restpos++;
2581 }
2582 }
2584 /*
2585 * In case of a partition, there are no new column definitions, only dummy
2586 * ColumnDefs created for column constraints. Set them aside for now and
2587 * process them at the end.
2588 */
2590 {
2593 }
2595 /*
2596 * Scan the parents left-to-right, and merge their attributes to form a
2597 * list of inherited columns (inh_columns).
2598 */
2601 {
2603 Relation relation;
2604 TupleDesc tupleDesc;
2615 /* caller already got lock */
2618 /*
2619 * Check for active uses of the parent partitioned table in the
2620 * current transaction, such as being used in some manner by an
2621 * enclosing command.
2622 */
2626 /*
2627 * We do not allow partitioned tables and partitions to participate in
2628 * regular inheritance.
2629 */
2649 /*
2650 * If the parent is permanent, so must be all of its partitions. Note
2651 * that inheritance allows that case.
2652 */
2661 /* Permanent rels cannot inherit from temporary ones */
2671 /* If existing rel is temp, it must belong to this session */
2680 /*
2681 * We should have an UNDER permission flag for this, but for now,
2682 * demand that creator of a child table own the parent.
2683 */
2691 /*
2692 * newattmap->attnums[] will contain the child-table attribute numbers
2693 * for the attributes of this parent table. (They are not the same
2694 * for parents after the first one, nor if we have dropped columns.)
2695 */
2698 /* We can't process inherited defaults until newattmap is complete. */
2701 /*
2702 * All columns that are part of the parent's primary key need to be
2703 * NOT NULL; if partition just the attnotnull bit, otherwise a full
2704 * constraint (if they don't have one already). Also, we request
2705 * attnotnull on columns that have a not-null constraint that's not
2706 * marked NO INHERIT.
2707 */
2709 INDEX_ATTR_BITMAP_PRIMARY_KEY);
2716 parent_attno++)
2717 {
2725 /*
2726 * Ignore dropped columns in the parent.
2727 */
2731 /*
2732 * Create new column definition
2733 */
2742 /*
2743 * Regular inheritance children are independent enough not to
2744 * inherit identity columns. But partitions are integral part of
2745 * a partitioned table and inherit identity column.
2746 */
2750 /*
2751 * Does it match some previously considered column from another
2752 * parent?
2753 */
2756 {
2757 /*
2758 * Yes, try to merge the two column definitions.
2759 */
2764 /*
2765 * Partitions have only one parent, so conflict should never
2766 * occur.
2767 */
2769 }
2770 else
2771 {
2772 /*
2773 * No, create a new inherited column
2774 */
2782 }
2784 /*
2785 * mark attnotnull if parent has it and it's not NO INHERIT
2786 */
2789 pkattrs))
2792 /*
2793 * In regular inheritance, columns in the parent's primary key get
2794 * an extra not-null constraint. Partitioning doesn't need this,
2795 * because the PK itself is going to be cloned to the partition.
2796 */
2799 FirstLowInvalidHeapAttributeNumber,
2800 pkattrs))
2801 {
2816 }
2818 /*
2819 * Locate default/generation expression if any
2820 */
2822 {
2830 /*
2831 * If it's a GENERATED default, it might contain Vars that
2832 * need to be mapped to the inherited column(s)' new numbers.
2833 * We can't do that till newattmap is ready, so just remember
2834 * all the inherited default expressions for the moment.
2835 */
2838 }
2839 }
2841 /*
2842 * Now process any inherited default expressions, adjusting attnos
2843 * using the completed newattmap map.
2844 */
2846 {
2851 /* Adjust Vars to match new table's column numbering */
2854 newattmap,
2857 /*
2858 * For the moment we have to reject whole-row variables. We could
2859 * convert them, if we knew the new table's rowtype OID, but that
2860 * hasn't been assigned yet. (A variable could only appear in a
2861 * generation expression, so the error message is correct.)
2862 */
2867 errdetail("Generation expression for column \"%s\" contains a whole-row reference to table \"%s\".",
2871 /*
2872 * If we already had a default from some prior parent, check to
2873 * see if they are the same. If so, no problem; if not, mark the
2874 * column as having a bogus default. Below, we will complain if
2875 * the bogus default isn't overridden by the child columns.
2876 */
2881 {
2884 }
2885 }
2887 /*
2888 * Now copy the CHECK constraints of this parent, adjusting attnos
2889 * using the completed newattmap map. Identically named constraints
2890 * are merged if possible, else we throw error.
2891 */
2893 {
2897 {
2902 /* ignore if the constraint is non-inheritable */
2906 /* Adjust Vars to match new table's column numbering */
2909 newattmap,
2912 /*
2913 * For the moment we have to reject whole-row variables. We
2914 * could convert them, if we knew the new table's rowtype OID,
2915 * but that hasn't been assigned yet.
2916 */
2922 name,
2926 }
2927 }
2929 /*
2930 * Also copy the not-null constraints from this parent. The
2931 * attnotnull markings were already installed above.
2932 */
2934 {
2944 }
2948 /*
2949 * Close the parent rel, but keep our lock on it until xact commit.
2950 * That will prevent someone else from deleting or ALTERing the parent
2951 * before the child is committed.
2952 */
2954 }
2956 /*
2957 * If we had no inherited attributes, the result columns are just the
2958 * explicitly declared columns. Otherwise, we need to merge the declared
2959 * columns into the inherited column list. Although, we never have any
2960 * explicitly declared columns if the table is a partition.
2961 */
2963 {
2967 {
2972 /*
2973 * Partitions have only one parent and have no column definitions
2974 * of their own, so conflict should never occur.
2975 */
2978 newcol_attno++;
2980 /*
2981 * Does it match some inherited column?
2982 */
2985 {
2986 /*
2987 * Yes, try to merge the two column definitions.
2988 */
2990 }
2991 else
2992 {
2993 /*
2994 * No, attach new column unchanged to result columns.
2995 */
2997 }
2998 }
3002 /*
3003 * Check that we haven't exceeded the legal # of columns after merging
3004 * in inherited columns.
3005 */
3010 MaxHeapAttributeNumber)));
3011 }
3013 /*
3014 * Now that we have the column definition list for a partition, we can
3015 * check whether the columns referenced in the column constraint specs
3016 * actually exist. Also, merge column defaults.
3017 */
3019 {
3021 {
3027 {
3031 {
3034 /*
3035 * Check for conflicts related to generated columns.
3036 *
3037 * Same rules as above: generated-ness has to match the
3038 * parent, but the contents of the generation expression
3039 * can be different.
3040 */
3042 {
3053 }
3054 else
3055 {
3062 }
3064 /*
3065 * Override the parent's default value for this column
3066 * (coldef->cooked_default) with the partition's local
3067 * definition (restdef->raw_default), if there's one. It
3068 * should be physically impossible to get a cooked default
3069 * in the local definition or a raw default in the
3070 * inherited definition, but make sure they're nulls, for
3071 * future-proofing.
3072 */
3076 {
3079 }
3080 }
3081 }
3083 /* complain for constraints on columns not in parent */
3089 }
3090 }
3092 /*
3093 * If we found any conflicting parent default values, check to make sure
3094 * they were overridden by the child.
3095 */
3097 {
3099 {
3103 {
3110 else
3116 }
3117 }
3118 }
3124 }
3127 /*
3128 * MergeCheckConstraint
3129 * Try to merge an inherited CHECK constraint with previous ones
3130 *
3131 * If we inherit identically-named constraints from multiple parents, we must
3132 * merge them, or throw an error if they don't have identical definitions.
3133 *
3134 * constraints is a list of CookedConstraint structs for previous constraints.
3135 *
3136 * If the new constraint matches an existing one, then the existing
3137 * constraint's inheritance count is updated. If there is a conflict (same
3138 * name but different expression), throw an error. If the constraint neither
3139 * matches nor conflicts with an existing one, a new constraint is appended to
3140 * the list.
3141 */
3144 {
3149 {
3154 /* Non-matching names never conflict */
3159 {
3160 /* OK to merge constraint with existing */
3167 }
3172 name)));
3173 }
3175 /*
3176 * Constraint couldn't be merged with an existing one and also didn't
3177 * conflict with an existing one, so add it as a new one to the list.
3178 */
3185 }
3187 /*
3188 * MergeChildAttribute
3189 * Merge given child attribute definition into given inherited attribute.
3190 *
3191 * Input arguments:
3192 * 'inh_columns' is the list of inherited ColumnDefs.
3193 * 'exist_attno' is the number of the inherited attribute in inh_columns
3194 * 'newcol_attno' is the attribute number in child table's schema definition
3195 * 'newdef' is the column/attribute definition from the child table.
3196 *
3197 * The ColumnDef in 'inh_columns' list is modified. The child attribute's
3198 * ColumnDef remains unchanged.
3199 *
3200 * Notes:
3201 * - The attribute is merged according to the rules laid out in the prologue
3202 * of MergeAttributes().
3203 * - If matching inherited attribute exists but the child attribute can not be
3204 * merged into it, the function throws respective errors.
3205 * - A partition can not have its own column definitions. Hence this function
3206 * is applicable only to a regular inheritance child.
3207 */
3208 static void
3209 MergeChildAttribute(List *inh_columns, int exist_attno, int newcol_attno, const ColumnDef *newdef)
3210 {
3213 Oid inhtypeid,
3214 newtypeid;
3215 int32 inhtypmod,
3216 newtypmod;
3217 Oid inhcollid,
3218 newcollid;
3223 attributeName)));
3224 else
3231 /*
3232 * Must have the same type and typmod
3233 */
3240 attributeName),
3245 /*
3246 * Must have the same collation
3247 */
3254 attributeName),
3259 /*
3260 * Identity is never inherited by a regular inheritance child. Pick
3261 * child's identity definition if there's one.
3262 */
3265 /*
3266 * Copy storage parameter
3267 */
3274 attributeName),
3279 /*
3280 * Copy compression parameter
3281 */
3285 {
3290 attributeName),
3292 }
3294 /*
3295 * Merge of not-null constraints = OR 'em together
3296 */
3299 /*
3300 * Check for conflicts related to generated columns.
3301 *
3302 * If the parent column is generated, the child column will be made a
3303 * generated column if it isn't already. If it is a generated column,
3304 * we'll take its generation expression in preference to the parent's. We
3305 * must check that the child column doesn't specify a default value or
3306 * identity, which matches the rules for a single column in
3307 * parse_utilcmd.c.
3308 *
3309 * Conversely, if the parent column is not generated, the child column
3310 * can't be either. (We used to allow that, but it results in being able
3311 * to override the generation expression via UPDATEs through the parent.)
3312 */
3314 {
3325 }
3326 else
3327 {
3334 }
3336 /*
3337 * If new def has a default, override previous default
3338 */
3340 {
3343 }
3345 /* Mark the column as locally defined */
3347 }
3349 /*
3350 * MergeInheritedAttribute
3351 * Merge given parent attribute definition into specified attribute
3352 * inherited from the previous parents.
3353 *
3354 * Input arguments:
3355 * 'inh_columns' is the list of previously inherited ColumnDefs.
3356 * 'exist_attno' is the number the existing matching attribute in inh_columns.
3357 * 'newdef' is the new parent column/attribute definition to be merged.
3358 *
3359 * The matching ColumnDef in 'inh_columns' list is modified and returned.
3360 *
3361 * Notes:
3362 * - The attribute is merged according to the rules laid out in the prologue
3363 * of MergeAttributes().
3364 * - If matching inherited attribute exists but the new attribute can not be
3365 * merged into it, the function throws respective errors.
3366 * - A partition inherits from only a single parent. Hence this function is
3367 * applicable only to a regular inheritance.
3368 */
3373 {
3376 Oid prevtypeid,
3377 newtypeid;
3378 int32 prevtypmod,
3379 newtypmod;
3380 Oid prevcollid,
3381 newcollid;
3385 attributeName)));
3388 /*
3389 * Must have the same type and typmod
3390 */
3397 attributeName),
3402 /*
3403 * Must have the same collation
3404 */
3411 attributeName),
3416 /*
3417 * Copy/check storage parameter
3418 */
3425 attributeName),
3430 /*
3431 * Copy/check compression parameter
3432 */
3436 {
3441 attributeName),
3444 }
3446 /*
3447 * Check for GENERATED conflicts
3448 */
3453 attributeName)));
3455 /*
3456 * Default and other constraints are handled by the caller.
3457 */
3466 }
3468 /*
3469 * StoreCatalogInheritance
3470 * Updates the system catalogs with proper inheritance information.
3471 *
3472 * supers is a list of the OIDs of the new relation's direct ancestors.
3473 */
3474 static void
3477 {
3478 Relation relation;
3479 int32 seqNumber;
3482 /*
3483 * sanity checks
3484 */
3490 /*
3491 * Store INHERITS information in pg_inherits using direct ancestors only.
3492 * Also enter dependencies on the direct ancestors, and make sure they are
3493 * marked with relhassubclass = true.
3494 *
3495 * (Once upon a time, both direct and indirect ancestors were found here
3496 * and then entered into pg_ipl. Since that catalog doesn't exist
3497 * anymore, there's no need to look for indirect ancestors.)
3498 */
3503 {
3507 child_is_partition);
3508 seqNumber++;
3509 }
3512 }
3514 /*
3515 * Make catalog entries showing relationId as being an inheritance child
3516 * of parentOid. inhRelation is the already-opened pg_inherits catalog.
3517 */
3518 static void
3522 {
3523 ObjectAddress childobject,
3524 parentobject;
3526 /* store the pg_inherits row */
3529 /*
3530 * Store a dependency too
3531 */
3542 /*
3543 * Post creation hook of this inheritance. Since object_access_hook
3544 * doesn't take multiple object identifiers, we relay oid of parent
3545 * relation using auxiliary_id argument.
3546 */
3551 /*
3552 * Mark the parent as having subclasses.
3553 */
3555 }
3557 /*
3558 * Look for an existing column entry with the given name.
3559 *
3560 * Returns the index (starting with 1) if attribute already exists in columns,
3561 * 0 if it doesn't.
3562 */
3563 static int
3565 {
3570 {
3574 i++;
3575 }
3577 }
3580 /*
3581 * SetRelationHasSubclass
3582 * Set the value of the relation's relhassubclass field in pg_class.
3583 *
3584 * NOTE: caller must be holding an appropriate lock on the relation.
3585 * ShareUpdateExclusiveLock is sufficient.
3586 *
3587 * NOTE: an important side-effect of this operation is that an SI invalidation
3588 * message is sent out to all backends --- including me --- causing plans
3589 * referencing the relation to be rebuilt with the new list of children.
3590 * This must happen even if we find that no change is needed in the pg_class
3591 * row.
3592 */
3593 void
3595 {
3596 Relation relationRelation;
3597 HeapTuple tuple;
3598 Form_pg_class classtuple;
3600 /*
3601 * Fetch a modifiable copy of the tuple, modify it, update pg_class.
3602 */
3610 {
3613 }
3614 else
3615 {
3616 /* no need to change tuple, but force relcache rebuild anyway */
3618 }
3622 }
3624 /*
3625 * CheckRelationTableSpaceMove
3626 * Check if relation can be moved to new tablespace.
3627 *
3628 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3629 *
3630 * Returns true if the relation can be moved to the new tablespace; raises
3631 * an error if it is not possible to do the move; returns false if the move
3632 * would have no effect.
3633 */
3634 bool
3636 {
3637 Oid oldTableSpaceId;
3639 /*
3640 * No work if no change in tablespace. Note that MyDatabaseTableSpace is
3641 * stored as 0.
3642 */
3648 /*
3649 * We cannot support moving mapped relations into different tablespaces.
3650 * (In particular this eliminates all shared catalogs.)
3651 */
3658 /* Cannot move a non-shared relation into pg_global */
3664 /*
3665 * Do not allow moving temp tables of other backends ... their local
3666 * buffer manager is not going to cope.
3667 */
3674 }
3676 /*
3677 * SetRelationTableSpace
3678 * Set new reltablespace and relfilenumber in pg_class entry.
3679 *
3680 * newTableSpaceId is the new tablespace for the relation, and
3681 * newRelFilenumber its new filenumber. If newRelFilenumber is
3682 * InvalidRelFileNumber, this field is not updated.
3683 *
3684 * NOTE: The caller must hold AccessExclusiveLock on the relation.
3685 *
3686 * The caller of this routine had better check if a relation can be
3687 * moved to this new tablespace by calling CheckRelationTableSpaceMove()
3688 * first, and is responsible for making the change visible with
3689 * CommandCounterIncrement().
3690 */
3691 void
3693 Oid newTableSpaceId,
3694 RelFileNumber newRelFilenumber)
3695 {
3696 Relation pg_class;
3697 HeapTuple tuple;
3698 Form_pg_class rd_rel;
3703 /* Get a modifiable copy of the relation's pg_class row. */
3711 /* Update the pg_class row. */
3718 /*
3719 * Record dependency on tablespace. This is only required for relations
3720 * that have no physical storage.
3721 */
3728 }
3730 /*
3731 * renameatt_check - basic sanity checks before attribute rename
3732 */
3733 static void
3735 {
3743 /*
3744 * Renaming the columns of sequences or toast tables doesn't actually
3745 * break anything from the system's point of view, since internal
3746 * references are by attnum. But it doesn't seem right to allow users to
3747 * change names that are hardcoded into the system, hence the following
3748 * restriction.
3749 */
3764 /*
3765 * permissions checking. only the owner of a class can change its schema.
3766 */
3775 }
3777 /*
3778 * renameatt_internal - workhorse for renameatt
3779 *
3780 * Return value is the attribute number in the 'myrelid' relation.
3781 */
3782 static AttrNumber
3789 DropBehavior behavior)
3790 {
3791 Relation targetrelation;
3792 Relation attrelation;
3793 HeapTuple atttup;
3794 Form_pg_attribute attform;
3795 AttrNumber attnum;
3797 /*
3798 * Grab an exclusive lock on the target table, which we will NOT release
3799 * until end of transaction.
3800 */
3804 /*
3805 * if the 'recurse' flag is set then we are supposed to rename this
3806 * attribute in all classes that inherit from 'relname' (as well as in
3807 * 'relname').
3808 *
3809 * any permissions or problems with duplicate attributes will cause the
3810 * whole transaction to abort, which is what we want -- all or nothing.
3811 */
3813 {
3819 /*
3820 * we need the number of parents for each child so that the recursive
3821 * calls to renameatt() can determine whether there are any parents
3822 * outside the inheritance hierarchy being processed.
3823 */
3827 /*
3828 * find_all_inheritors does the recursive search of the inheritance
3829 * hierarchy, so all we have to do is process all of the relids in the
3830 * list that it returns.
3831 */
3833 {
3839 /* note we need not recurse again */
3841 }
3842 }
3843 else
3844 {
3845 /*
3846 * If we are told not to recurse, there had better not be any child
3847 * tables; else the rename would put them out of step.
3848 *
3849 * expected_parents will only be 0 if we are not already recursing.
3850 */
3856 oldattname)));
3857 }
3859 /* rename attributes in typed tables of composite type */
3861 {
3867 behavior);
3871 }
3880 oldattname)));
3888 oldattname)));
3890 /*
3891 * if the attribute is inherited, forbid the renaming. if this is a
3892 * top-level call to renameatt(), then expected_parents will be 0, so the
3893 * effect of this code will be to prohibit the renaming if the attribute
3894 * is inherited at all. if this is a recursive call to renameatt(),
3895 * expected_parents will be the number of parents the current relation has
3896 * within the inheritance hierarchy being processed, so we'll prohibit the
3897 * renaming only if there are additional parents from elsewhere.
3898 */
3903 oldattname)));
3905 /* new name should not already exist */
3908 /* apply the update */
3922 }
3924 /*
3925 * Perform permissions and integrity checks before acquiring a relation lock.
3926 */
3927 static void
3930 {
3931 HeapTuple tuple;
3932 Form_pg_class form;
3940 }
3942 /*
3943 * renameatt - changes the name of an attribute in a relation
3944 *
3945 * The returned ObjectAddress is that of the renamed column.
3946 */
3947 ObjectAddress
3949 {
3950 Oid relid;
3951 AttrNumber attnum;
3952 ObjectAddress address;
3954 /* lock level taken here should match renameatt_internal */
3957 RangeVarCallbackForRenameAttribute,
3958 NULL);
3961 {
3966 }
3968 attnum =
3980 }
3982 /*
3983 * same logic as renameatt_internal
3984 */
3985 static ObjectAddress
3987 Oid mytypid,
3993 {
3995 Oid constraintOid;
3996 HeapTuple tuple;
3997 Form_pg_constraint con;
3998 ObjectAddress address;
4003 {
4005 }
4006 else
4007 {
4010 /*
4011 * don't tell it whether we're recursing; we allow changing typed
4012 * tables here
4013 */
4017 }
4022 constraintOid);
4029 {
4031 {
4041 {
4048 rename_constraint_internal(childrelid, InvalidOid, oldconname, newconname, false, true, numparents);
4049 }
4050 }
4051 else
4052 {
4058 oldconname)));
4059 }
4065 oldconname)));
4066 }
4072 /* rename the index; this renames the constraint as well */
4074 else
4082 {
4083 /*
4084 * Invalidate relcache so as others can see the new constraint name.
4085 */
4089 }
4092 }
4094 ObjectAddress
4096 {
4101 {
4102 Relation rel;
4103 HeapTuple tup;
4113 }
4114 else
4115 {
4116 /* lock level taken here should match rename_constraint_internal */
4119 RangeVarCallbackForRenameAttribute,
4120 NULL);
4122 {
4127 }
4128 }
4130 return
4138 }
4140 /*
4141 * Execute ALTER TABLE/INDEX/SEQUENCE/VIEW/MATERIALIZED VIEW/FOREIGN TABLE
4142 * RENAME
4143 */
4144 ObjectAddress
4146 {
4148 Oid relid;
4149 ObjectAddress address;
4151 /*
4152 * Grab an exclusive lock on the target table, index, sequence, view,
4153 * materialized view, or foreign table, which we will NOT release until
4154 * end of transaction.
4155 *
4156 * Lock level used here should match RenameRelationInternal, to avoid lock
4157 * escalation. However, because ALTER INDEX can be used with any relation
4158 * type, we mustn't believe without verification.
4159 */
4161 {
4162 LOCKMODE lockmode;
4170 RangeVarCallbackForAlterRelation,
4174 {
4179 }
4181 /*
4182 * We allow mismatched statement and object types (e.g., ALTER INDEX
4183 * to rename a table), but we might've used the wrong lock level. If
4184 * that happens, retry with the correct lock level. We don't bother
4185 * if we already acquired AccessExclusiveLock with an index, however.
4186 */
4195 }
4197 /* Do the work */
4203 }
4205 /*
4206 * RenameRelationInternal - change the name of a relation
4207 */
4208 void
4210 {
4211 Relation targetrelation;
4213 HeapTuple reltup;
4214 Form_pg_class relform;
4215 Oid namespaceId;
4217 /*
4218 * Grab a lock on the target relation, which we will NOT release until end
4219 * of transaction. We need at least a self-exclusive lock so that
4220 * concurrent DDL doesn't overwrite the rename if they start updating
4221 * while still seeing the old version. The lock also guards against
4222 * triggering relcache reloads in concurrent sessions, which might not
4223 * handle this information changing under them. For indexes, we can use a
4224 * reduced lock level because RelationReloadIndexInfo() handles indexes
4225 * specially.
4226 */
4227 targetrelation = relation_open(myrelid, is_index ? ShareUpdateExclusiveLock : AccessExclusiveLock);
4230 /*
4231 * Find relation's pg_class tuple, and make sure newrelname isn't in use.
4232 */
4244 newrelname)));
4246 /*
4247 * RenameRelation is careful not to believe the caller's idea of the
4248 * relation kind being handled. We don't have to worry about this, but
4249 * let's not be totally oblivious to it. We can process an index as
4250 * not-an-index, but not the other way around.
4251 */
4256 /*
4257 * Update pg_class tuple with new relname. (Scribbling on reltup is OK
4258 * because it's a copy...)
4259 */
4270 /*
4271 * Also rename the associated type, if any.
4272 */
4277 /*
4278 * Also rename the associated constraint, if any.
4279 */
4282 {
4287 }
4289 /*
4290 * Close rel, but keep lock!
4291 */
4293 }
4295 /*
4296 * ResetRelRewrite - reset relrewrite
4297 */
4298 void
4300 {
4302 HeapTuple reltup;
4303 Form_pg_class relform;
4305 /*
4306 * Find relation's pg_class tuple.
4307 */
4315 /*
4316 * Update pg_class tuple.
4317 */
4324 }
4326 /*
4327 * Disallow ALTER TABLE (and similar commands) when the current backend has
4328 * any open reference to the target table besides the one just acquired by
4329 * the calling command; this implies there's an open cursor or active plan.
4330 * We need this check because our lock doesn't protect us against stomping
4331 * on our own foot, only other people's feet!
4332 *
4333 * For ALTER TABLE, the only case known to cause serious trouble is ALTER
4334 * COLUMN TYPE, and some changes are obviously pretty benign, so this could
4335 * possibly be relaxed to only error out for certain types of alterations.
4336 * But the use-case for allowing any of these things is not obvious, so we
4337 * won't work hard at it for now.
4338 *
4339 * We also reject these commands if there are any pending AFTER trigger events
4340 * for the rel. This is certainly necessary for the rewriting variants of
4341 * ALTER TABLE, because they don't preserve tuple TIDs and so the pending
4342 * events would try to fetch the wrong tuples. It might be overly cautious
4343 * in other cases, but again it seems better to err on the side of paranoia.
4344 *
4345 * REINDEX calls this with "rel" referencing the index to be rebuilt; here
4346 * we are worried about active indexscans on the index. The trigger-event
4347 * check can be skipped, since we are doing no damage to the parent table.
4348 *
4349 * The statement name (eg, "ALTER TABLE") is passed for use in error messages.
4350 */
4351 void
4353 {
4360 /* translator: first %s is a SQL command, eg ALTER TABLE */
4369 /* translator: first %s is a SQL command, eg ALTER TABLE */
4372 }
4374 /*
4375 * AlterTableLookupRelation
4376 * Look up, and lock, the OID for the relation named by an alter table
4377 * statement.
4378 */
4379 Oid
4381 {
4384 RangeVarCallbackForAlterRelation,
4386 }
4388 /*
4389 * AlterTable
4390 * Execute ALTER TABLE, which can be a list of subcommands
4391 *
4392 * ALTER TABLE is performed in three phases:
4393 * 1. Examine subcommands and perform pre-transformation checking.
4394 * 2. Validate and transform subcommands, and update system catalogs.
4395 * 3. Scan table(s) to check new constraints, and optionally recopy
4396 * the data into new table(s).
4397 * Phase 3 is not performed unless one or more of the subcommands requires
4398 * it. The intention of this design is to allow multiple independent
4399 * updates of the table schema to be performed with only one pass over the
4400 * data.
4401 *
4402 * ATPrepCmd performs phase 1. A "work queue" entry is created for
4403 * each table to be affected (there may be multiple affected tables if the
4404 * commands traverse a table inheritance hierarchy). Also we do preliminary
4405 * validation of the subcommands. Because earlier subcommands may change
4406 * the catalog state seen by later commands, there are limits to what can
4407 * be done in this phase. Generally, this phase acquires table locks,
4408 * checks permissions and relkind, and recurses to find child tables.
4409 *
4410 * ATRewriteCatalogs performs phase 2 for each affected table.
4411 * Certain subcommands need to be performed before others to avoid
4412 * unnecessary conflicts; for example, DROP COLUMN should come before
4413 * ADD COLUMN. Therefore phase 1 divides the subcommands into multiple
4414 * lists, one for each logical "pass" of phase 2.
4415 *
4416 * ATRewriteTables performs phase 3 for those tables that need it.
4417 *
4418 * For most subcommand types, phases 2 and 3 do no explicit recursion,
4419 * since phase 1 already does it. However, for certain subcommand types
4420 * it is only possible to determine how to recurse at phase 2 time; for
4421 * those cases, phase 1 sets the cmd->recurse flag.
4422 *
4423 * Thanks to the magic of MVCC, an error anywhere along the way rolls back
4424 * the whole operation; we don't have to do anything special to clean up.
4425 *
4426 * The caller must lock the relation, with an appropriate lock level
4427 * for the subcommands requested, using AlterTableGetLockLevel(stmt->cmds)
4428 * or higher. We pass the lock level down
4429 * so that we can apply it recursively to inherited tables. Note that the
4430 * lock level we want as we recurse might well be higher than required for
4431 * that specific subcommand. So we pass down the overall lock requirement,
4432 * rather than reassess it at lower levels.
4433 *
4434 * The caller also provides a "context" which is to be passed back to
4435 * utility.c when we need to execute a subcommand such as CREATE INDEX.
4436 * Some of the fields therein, such as the relid, are used here as well.
4437 */
4438 void
4441 {
4442 Relation rel;
4444 /* Caller is required to provide an adequate lock. */
4450 }
4452 /*
4453 * AlterTableInternal
4454 *
4455 * ALTER TABLE with target specified by OID
4456 *
4457 * We do not reject if the relation is already open, because it's quite
4458 * likely that one or more layers of caller have it open. That means it
4459 * is unsafe to use this entry point for alterations that could break
4460 * existing query plans. On the assumption it's not used for such, we
4461 * don't have to reject pending AFTER triggers, either.
4462 *
4463 * Also, since we don't have an AlterTableUtilityContext, this cannot be
4464 * used for any subcommand types that require parse transformation or
4465 * could generate subcommands that have to be passed to ProcessUtility.
4466 */
4467 void
4469 {
4470 Relation rel;
4478 }
4480 /*
4481 * AlterTableGetLockLevel
4482 *
4483 * Sets the overall lock level required for the supplied list of subcommands.
4484 * Policy for doing this set according to needs of AlterTable(), see
4485 * comments there for overall explanation.
4486 *
4487 * Function is called before and after parsing, so it must give same
4488 * answer each time it is called. Some subcommands are transformed
4489 * into other subcommand types, so the transform must never be made to a
4490 * lower lock level than previously assigned. All transforms are noted below.
4491 *
4492 * Since this is called before we lock the table we cannot use table metadata
4493 * to influence the type of lock we acquire.
4494 *
4495 * There should be no lockmodes hardcoded into the subcommand functions. All
4496 * lockmode decisions for ALTER TABLE are made here only. The one exception is
4497 * ALTER TABLE RENAME which is treated as a different statement type T_RenameStmt
4498 * and does not travel through this section of code and cannot be combined with
4499 * any of the subcommands given here.
4500 *
4501 * Note that Hot Standby only knows about AccessExclusiveLocks on the primary
4502 * so any changes that might affect SELECTs running on standbys need to use
4503 * AccessExclusiveLocks even if you think a lesser lock would do, unless you
4504 * have a solution for that also.
4505 *
4506 * Also note that pg_dump uses only an AccessShareLock, meaning that anything
4507 * that takes a lock less than AccessExclusiveLock can change object definitions
4508 * while pg_dump is running. Be careful to check that the appropriate data is
4509 * derived by pg_dump using an MVCC snapshot, rather than syscache lookups,
4510 * otherwise we might end up with an inconsistent dump that can't restore.
4511 */
4512 LOCKMODE
4514 {
4515 /*
4516 * This only works if we read catalog tables using MVCC snapshots.
4517 */
4522 {
4527 {
4528 /*
4529 * These subcommands rewrite the heap, so require full locks.
4530 */
4532 * to SELECT */
4539 /*
4540 * These subcommands may require addition of toast tables. If
4541 * we add a toast table to a table currently being scanned, we
4542 * might miss data added to the new toast table by concurrent
4543 * insert transactions.
4544 */
4546 * ATRewriteCatalogs() */
4550 /*
4551 * Removing constraints can affect SELECTs that have been
4552 * optimized assuming the constraint holds true. See also
4553 * CloneFkReferenced.
4554 */
4560 /*
4561 * Subcommands that may be visible to concurrent SELECTs
4562 */
4573 /*
4574 * Changing owner may remove implicit SELECT privileges
4575 */
4580 /*
4581 * Changing foreign table options may affect optimization.
4582 */
4588 /*
4589 * These subcommands affect write operations only.
4590 */
4602 /*
4603 * These subcommands affect write operations only. XXX
4604 * Theoretically, these could be ShareRowExclusiveLock.
4605 */
4631 {
4635 {
4640 /*
4641 * Cases essentially the same as CREATE INDEX. We
4642 * could reduce the lock strength to ShareLock if
4643 * we can work out how to allow concurrent catalog
4644 * updates. XXX Might be set down to
4645 * ShareRowExclusiveLock but requires further
4646 * analysis.
4647 */
4652 /*
4653 * We add triggers to both tables when we add a
4654 * Foreign Key, so the lock level must be at least
4655 * as strong as CREATE TRIGGER.
4656 */
4662 }
4663 }
4666 /*
4667 * These subcommands affect inheritance behaviour. Queries
4668 * started before us will continue to see the old inheritance
4669 * behaviour, while queries started after we commit will see
4670 * new behaviour. No need to prevent reads or writes to the
4671 * subtable while we hook it up though. Changing the TupDesc
4672 * may be a problem, so keep highest lock.
4673 */
4679 /*
4680 * These subcommands affect implicit row type conversion. They
4681 * have affects similar to CREATE/DROP CAST on queries. don't
4682 * provide for invalidating parse trees as a result of such
4683 * changes, so we keep these at AccessExclusiveLock.
4684 */
4690 /*
4691 * Only used by CREATE OR REPLACE VIEW which must conflict
4692 * with an SELECTs currently using the view.
4693 */
4698 /*
4699 * These subcommands affect general strategies for performance
4700 * and maintenance, though don't change the semantic results
4701 * from normal data reads and writes. Delaying an ALTER TABLE
4702 * behind currently active writes only delays the point where
4703 * the new strategy begins to take effect, so there is no
4704 * benefit in waiting. In this case the minimum restriction
4705 * applies: we don't currently allow concurrent catalog
4706 * updates.
4707 */
4725 /*
4726 * Rel options are more complex than first appears. Options
4727 * are set here for tables, views and indexes; for historical
4728 * reasons these can all be used with ALTER TABLE, so we can't
4729 * decide between them using the basic grammar.
4730 */
4732 * getTables() */
4734 * getTables() */
4745 else
4765 }
4767 /*
4768 * Take the greatest lockmode from any subcommand
4769 */
4772 }
4775 }
4777 /*
4778 * ATController provides top level control over the phases.
4779 *
4780 * parsetree is passed in to allow it to be passed to event triggers
4781 * when requested.
4782 */
4783 static void
4787 {
4791 /* Phase 1: preliminary examination of commands, create work queue */
4793 {
4797 }
4799 /* Close the relation, but keep lock until commit */
4802 /* Phase 2: update system catalogs */
4805 /* Phase 3: scan/rewrite tables as needed, and run afterStmts */
4807 }
4809 /*
4810 * ATPrepCmd
4811 *
4812 * Traffic cop for ALTER TABLE Phase 1 operations, including simple
4813 * recursion and permission checks.
4814 *
4815 * Caller must have acquired appropriate lock type on relation already.
4816 * This lock should be held until commit.
4817 */
4818 static void
4822 {
4826 /* Find or create work queue entry for this table */
4829 /*
4830 * Disallow any ALTER TABLE other than ALTER TABLE DETACH FINALIZE on
4831 * partitions that are pending detach.
4832 */
4840 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
4842 /*
4843 * Copy the original subcommand for each table, so we can scribble on it.
4844 * This avoids conflicts when different child tables need to make
4845 * different parse transformations (for example, the same column may have
4846 * different column numbers in different children).
4847 */
4850 /*
4851 * Do permissions and relkind checking, recursion to child tables if
4852 * needed, and any additional phase-1 processing needed. (But beware of
4853 * adding any processing that looks at table details that another
4854 * subcommand could change. In some cases we reject multiple subcommands
4855 * that could try to change the same state in contrary ways.)
4856 */
4858 {
4864 /* Recursion occurs during execution phase */
4871 /* Recursion occurs during execution phase */
4876 /*
4877 * We allow defaults on views so that INSERT into a view can have
4878 * default-ish behavior. This works because the rewriter
4879 * substitutes default values into INSERTs before it expands
4880 * rules.
4881 */
4884 /* No command-specific prep needed */
4888 /* This is currently used only in CREATE TABLE */
4889 /* (so the permission check really isn't necessary) */
4891 /* This command never recurses */
4896 /* Set up recursion for phase 2; no other prep needed */
4903 /* Set up recursion for phase 2; no other prep needed */
4906 /* This should run after AddIdentity, so do it in MISC pass */
4911 /* Set up recursion for phase 2; no other prep needed */
4918 /* Set up recursion for phase 2; no other prep needed */
4925 /* Set up recursion for phase 2; no other prep needed */
4931 * a constraint */
4933 /* Need command-specific recursion decision */
4949 ATSimplePermissions(cmd->subtype, rel, ATT_TABLE | ATT_MATVIEW | ATT_INDEX | ATT_PARTITIONED_INDEX | ATT_FOREIGN_TABLE);
4951 /* No command-specific prep needed */
4957 /* This command never recurses */
4963 /* No command-specific prep needed */
4968 /* This command never recurses */
4969 /* No command-specific prep needed */
4977 /* Recursion occurs during execution phase */
4982 /* This command never recurses */
4983 /* No command-specific prep needed */
4989 {
4990 /* recurses at exec time; lock descendants and set flag */
4993 }
4998 /* This command never recurses */
4999 /* No command-specific prep needed */
5005 /* Other recursion occurs during execution phase */
5006 /* No command-specific prep needed except saving recurse flag */
5014 /* See comments for ATPrepAlterColumnType */
5018 /* Performs own recursion */
5025 /* This command never recurses */
5026 /* No command-specific prep needed */
5030 /* This command never recurses */
5031 /* No command-specific prep needed */
5037 /* These commands never recurse */
5038 /* No command-specific prep needed */
5048 /* force rewrite if necessary; see comment in ATRewriteTables */
5050 {
5053 }
5063 /* force rewrite if necessary; see comment in ATRewriteTables */
5065 {
5068 }
5078 /* check if another access method change was already requested */
5089 ATT_PARTITIONED_INDEX);
5090 /* This command never recurses */
5098 /* This command never recurses */
5099 /* No command-specific prep needed */
5104 /* This command never recurses */
5110 /* This command never recurses */
5111 /* No command-specific prep needed */
5116 /* Recursion occurs during execution phase */
5121 /* Recursion occurs during execution phase */
5122 /* No command-specific prep needed except saving recurse flag */
5130 /* This command never recurses */
5131 /* No command-specific prep needed */
5142 /* Set up recursion for phase 2; no other prep needed */
5158 /* These commands never recurse */
5159 /* No command-specific prep needed */
5164 /* No command-specific prep needed */
5169 /* No command-specific prep needed */
5174 /* No command-specific prep needed */
5179 /* No command-specific prep needed */
5184 /* No command-specific prep needed */
5189 /* No command-specific prep needed */
5197 }
5200 /* Add the subcommand to the appropriate list for phase 2 */
5202 }
5204 /*
5205 * ATRewriteCatalogs
5206 *
5207 * Traffic cop for ALTER TABLE Phase 2 operations. Subcommands are
5208 * dispatched in a "safe" execution order (designed to avoid unnecessary
5209 * conflicts).
5210 */
5211 static void
5214 {
5217 /*
5218 * We process all the tables "in parallel", one pass at a time. This is
5219 * needed because we may have to propagate work from one table to another
5220 * (specifically, ALTER TYPE on a foreign key's PK has to dispatch the
5221 * re-adding of the foreign key constraint to the other table). Work can
5222 * only be propagated into later passes, however.
5223 */
5225 {
5226 /* Go through each table that needs to be processed */
5228 {
5236 /*
5237 * Open the relation and store it in tab. This allows subroutines
5238 * close and reopen, if necessary. Appropriate lock was obtained
5239 * by phase 1, needn't get it again.
5240 */
5248 /*
5249 * After the ALTER TYPE or SET EXPRESSION pass, do cleanup work
5250 * (this is not done in ATExecAlterColumnType since it should be
5251 * done only once if multiple columns of a table are altered).
5252 */
5257 {
5260 }
5261 }
5262 }
5264 /* Check to see if a toast table must be added. */
5266 {
5269 /*
5270 * If the table is source table of ATTACH PARTITION command, we did
5271 * not modify anything about it that will change its toasting
5272 * requirement, so no need to check.
5273 */
5279 }
5280 }
5282 /*
5283 * ATExecCmd: dispatch a subcommand to appropriate execution routine
5284 */
5285 static void
5289 {
5294 {
5352 lockmode);
5358 NULL);
5362 lockmode);
5366 lockmode);
5373 /* Transform the command only during initial examination */
5378 /* Depending on constraint type, might be no more work to do now */
5380 address =
5386 address =
5391 * constraint */
5392 address =
5395 NULL);
5402 lockmode);
5417 /* parse transformation was done earlier */
5421 address =
5440 /* nothing to do here, oid columns don't exist anymore */
5444 /*
5445 * Only do this for partitioned tables, for which this is just a
5446 * catalog change. Tables with storage are handled by Phase 3.
5447 */
5454 /*
5455 * Only do this for partitioned tables and indexes, for which this
5456 * is just a catalog change. Other relation types which have
5457 * storage are handled by Phase 3.
5458 */
5473 lockmode);
5479 lockmode);
5485 lockmode);
5491 lockmode);
5497 lockmode);
5503 lockmode);
5509 lockmode);
5515 lockmode);
5571 context);
5572 else
5580 /* ATPrepCmd ensures it must be a table */
5595 context);
5603 context);
5609 }
5611 /*
5612 * Report the subcommand to interested event triggers.
5613 */
5617 /*
5618 * Bump the command counter to ensure the next subcommand in the sequence
5619 * can see the changes so far
5620 */
5622 }
5624 /*
5625 * ATParseTransformCmd: perform parse transformation for one subcommand
5626 *
5627 * Returns the transformed subcommand tree, if there is one, else NULL.
5628 *
5629 * The parser may hand back additional AlterTableCmd(s) and/or other
5630 * utility statements, either before or after the original subcommand.
5631 * Other AlterTableCmds are scheduled into the appropriate slot of the
5632 * AlteredTableInfo (they had better be for later passes than the current one).
5633 * Utility statements that are supposed to happen before the AlterTableCmd
5634 * are executed immediately. Those that are supposed to happen afterwards
5635 * are added to the tab->afterStmts list to be done at the very end.
5636 */
5641 {
5648 /* Gin up an AlterTableStmt with just this subcommand and this table */
5658 /* Transform the AlterTableStmt */
5660 atstmt,
5665 /* Execute any statements that should happen before these subcommand(s) */
5667 {
5672 }
5674 /* Examine the transformed subcommands and schedule them appropriately */
5676 {
5678 AlterTablePass pass;
5680 /*
5681 * This switch need only cover the subcommand types that can be added
5682 * by parse_utilcmd.c; otherwise, we'll use the default strategy of
5683 * executing the subcommand immediately, as a substitute for the
5684 * original subcommand. (Note, however, that this does cause
5685 * AT_AddConstraint subcommands to be rescheduled into later passes,
5686 * which is important for index and foreign key constraints.)
5687 *
5688 * We assume we needn't do any phase-1 checks for added subcommands.
5689 */
5691 {
5698 /*
5699 * A primary key on an inheritance parent needs supporting NOT
5700 * NULL constraint on its children; enqueue commands to create
5701 * those or mark them inherited if they already exist.
5702 */
5707 /* as above */
5712 /* Recursion occurs during execution phase */
5716 {
5725 }
5728 /* This command never recurses */
5729 /* No command-specific prep needed */
5735 }
5738 {
5739 /* Cannot schedule into a pass we already finished */
5741 pass);
5742 }
5744 {
5745 /* OK, queue it up for later */
5747 }
5748 else
5749 {
5750 /*
5751 * We should see at most one subcommand for the current pass,
5752 * which is the transformed version of the original subcommand.
5753 */
5755 {
5756 /* Found the transformed version of our subcommand */
5758 }
5759 else
5761 pass);
5762 }
5763 }
5765 /* Queue up any after-statements to happen at the end */
5769 }
5771 /*
5772 * ATRewriteTables: ALTER TABLE phase 3
5773 */
5774 static void
5777 {
5780 /* Go through each table that needs to be checked or rewritten */
5782 {
5785 /* Relations without storage may be ignored here */
5789 /*
5790 * If we change column data types, the operation has to be propagated
5791 * to tables that use this table's rowtype as a column type.
5792 * tab->newvals will also be non-NULL in the case where we're adding a
5793 * column with a default. We choose to forbid that case as well,
5794 * since composite types might eventually support defaults.
5795 *
5796 * (Eventually we'll probably need to check for composite type
5797 * dependencies even when we're just scanning the table without a
5798 * rewrite, but at the moment a composite type does not enforce any
5799 * constraints, so it's not necessary/appropriate to enforce them just
5800 * during ALTER.)
5801 */
5803 {
5804 Relation rel;
5809 }
5811 /*
5812 * We only need to rewrite the table if at least one column needs to
5813 * be recomputed, or we are changing its persistence or access method.
5814 *
5815 * There are two reasons for requiring a rewrite when changing
5816 * persistence: on one hand, we need to ensure that the buffers
5817 * belonging to each of the two relations are marked with or without
5818 * BM_PERMANENT properly. On the other hand, since rewriting creates
5819 * and assigns a new relfilenumber, we automatically create or drop an
5820 * init fork for the relation as appropriate.
5821 */
5823 {
5824 /* Build a temporary relation and copy data */
5825 Relation OldHeap;
5826 Oid OIDNewHeap;
5827 Oid NewAccessMethod;
5828 Oid NewTableSpace;
5833 /*
5834 * We don't support rewriting of system catalogs; there are too
5835 * many corner cases and too little benefit. In particular this
5836 * is certainly not going to work for mapped catalogs.
5837 */
5850 /*
5851 * Don't allow rewrite on temp tables of other backends ... their
5852 * local buffer manager is not going to cope.
5853 */
5859 /*
5860 * Select destination tablespace (same as original unless user
5861 * requested a change)
5862 */
5865 else
5868 /*
5869 * Select destination access method (same as original unless user
5870 * requested a change)
5871 */
5874 else
5877 /*
5878 * Select persistence of transient table (same as original unless
5879 * user requested a change)
5880 */
5886 /*
5887 * Fire off an Event Trigger now, before actually rewriting the
5888 * table.
5889 *
5890 * We don't support Event Trigger for nested commands anywhere,
5891 * here included, and parsetree is given NULL when coming from
5892 * AlterTableInternal.
5893 *
5894 * And fire it only once.
5895 */
5901 /*
5902 * Create transient table that will receive the modified data.
5903 *
5904 * Ensure it is marked correctly as logged or unlogged. We have
5905 * to do this here so that buffers for the new relfilenumber will
5906 * have the right persistence set, and at the same time ensure
5907 * that the original filenumbers's buffers will get read in with
5908 * the correct setting (i.e. the original one). Otherwise a
5909 * rollback after the rewrite would possibly result with buffers
5910 * for the original filenumbers having the wrong persistence
5911 * setting.
5912 *
5913 * NB: This relies on swap_relation_files() also swapping the
5914 * persistence. That wouldn't work for pg_class, but that can't be
5915 * unlogged anyway.
5916 */
5920 /*
5921 * Copy the heap data into the new table with the desired
5922 * modifications, and test the current data within the table
5923 * against new constraints generated by ALTER TABLE commands.
5924 */
5927 /*
5928 * Swap the physical files of the old and new heaps, then rebuild
5929 * indexes and discard the old heap. We can use RecentXmin for
5930 * the table's new relfrozenxid because we rewrote all the tuples
5931 * in ATRewriteTable, so no older Xid remains in the table. Also,
5932 * we never try to swap toast tables by content, since we have no
5933 * interest in letting this code work on system catalogs.
5934 */
5938 RecentXmin,
5940 persistence);
5943 }
5945 {
5948 }
5949 else
5950 {
5951 /*
5952 * If required, test the current data within the table against new
5953 * constraints generated by ALTER TABLE commands, but don't
5954 * rebuild data.
5955 */
5960 /*
5961 * If we had SET TABLESPACE but no reason to reconstruct tuples,
5962 * just do a block-by-block copy.
5963 */
5966 }
5968 /*
5969 * Also change persistence of owned sequences, so that it matches the
5970 * table persistence.
5971 */
5973 {
5978 {
5982 }
5983 }
5984 }
5986 /*
5987 * Foreign key constraints are checked in a final pass, since (a) it's
5988 * generally best to examine each one separately, and (b) it's at least
5989 * theoretically possible that we have changed both relations of the
5990 * foreign key, and we'd better have finished both rewrites before we try
5991 * to read the tables.
5992 */
5994 {
5999 /* Relations without storage may be ignored here too */
6004 {
6008 {
6010 Relation refrel;
6013 {
6014 /* Long since locked, no need for another */
6016 }
6025 /*
6026 * No need to mark the constraint row as validated, we did
6027 * that when we inserted the row earlier.
6028 */
6031 }
6032 }
6036 }
6038 /* Finally, run any afterStmts that were queued up */
6040 {
6045 {
6050 }
6051 }
6052 }
6054 /*
6055 * ATRewriteTable: scan or rewrite one table
6056 *
6057 * OIDNewHeap is InvalidOid if we don't need to rewrite
6058 */
6059 static void
6061 {
6062 Relation oldrel;
6063 Relation newrel;
6064 TupleDesc oldTupDesc;
6065 TupleDesc newTupDesc;
6071 CommandId mycid;
6072 BulkInsertState bistate;
6076 /*
6077 * Open the relation(s). We have surely already locked the existing
6078 * table.
6079 */
6086 else
6089 /*
6090 * Prepare a BulkInsertState and options for table_tuple_insert. The FSM
6091 * is empty, so don't bother using it.
6092 */
6094 {
6098 }
6099 else
6100 {
6101 /* keep compiler quiet about using these uninitialized */
6105 }
6107 /*
6108 * Generate the constraint and default execution states
6109 */
6113 /* Build the needed expression execution states */
6115 {
6119 {
6125 /* Nothing to do here */
6130 }
6131 }
6133 /* Build expression execution states for partition check quals */
6135 {
6138 }
6141 {
6144 /* expr already planned */
6146 }
6150 {
6151 /*
6152 * If we are rebuilding the tuples OR if we added any new but not
6153 * verified not-null constraints, check all not-null constraints. This
6154 * is a bit of overkill but it minimizes risk of bugs, and
6155 * heap_attisnull is a pretty cheap test anyway.
6156 */
6158 {
6163 }
6166 }
6169 {
6173 TableScanDesc scan;
6174 MemoryContext oldCxt;
6177 Snapshot snapshot;
6183 else
6189 {
6190 /*
6191 * All predicate locks on the tuples or pages are about to be made
6192 * invalid, because we move tuples around. Promote them to
6193 * relation locks.
6194 */
6196 }
6200 /*
6201 * Create necessary tuple slots. When rewriting, two slots are needed,
6202 * otherwise one suffices. In the case where one slot suffices, we
6203 * need to use the new tuple descriptor, otherwise some constraints
6204 * can't be evaluated. Note that even when the tuple layout is the
6205 * same and no rewrite is required, the tupDescs might not be
6206 * (consider ADD COLUMN without a default).
6207 */
6209 {
6216 /*
6217 * Set all columns in the new slot to NULL initially, to ensure
6218 * columns added as part of the rewrite are initialized to NULL.
6219 * That is necessary as tab->newvals will not contain an
6220 * expression for columns with a NULL default, e.g. when adding a
6221 * column without a default together with a column with a default
6222 * requiring an actual rewrite.
6223 */
6225 }
6226 else
6227 {
6231 }
6233 /*
6234 * Any attributes that are dropped according to the new tuple
6235 * descriptor can be set to NULL. We precompute the list of dropped
6236 * attributes to avoid needing to do so in the per-tuple loop.
6237 */
6239 {
6242 }
6244 /*
6245 * Scan through the rows, generating a new row if needed and then
6246 * checking all the constraints.
6247 */
6251 /*
6252 * Switch to per-tuple memory context and reset it for each tuple
6253 * produced, so we don't leak memory.
6254 */
6258 {
6262 {
6263 /* Extract data from old tuple */
6267 /* copy attributes */
6273 /* Set dropped attributes to null in new tuple */
6277 /*
6278 * Constraints and GENERATED expressions might reference the
6279 * tableoid column, so fill tts_tableOid with the desired
6280 * value. (We must do this each time, because it gets
6281 * overwritten with newrel's OID during storing.)
6282 */
6285 /*
6286 * Process supplied expressions to replace selected columns.
6287 *
6288 * First, evaluate expressions whose inputs come from the old
6289 * tuple.
6290 */
6294 {
6302 econtext,
6304 }
6308 /*
6309 * Now, evaluate any expressions whose inputs come from the
6310 * new tuple. We assume these columns won't reference each
6311 * other, so that there's no ordering dependency.
6312 */
6316 {
6324 econtext,
6326 }
6329 }
6330 else
6331 {
6332 /*
6333 * If there's no rewrite, old and new table are guaranteed to
6334 * have the same AM, so we can just use the old slot to verify
6335 * new constraints etc.
6336 */
6338 }
6340 /* Now check any constraints on the possibly-changed tuple */
6344 {
6348 {
6357 }
6358 }
6361 {
6365 {
6377 /* Nothing to do here */
6382 }
6383 }
6386 {
6390 errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
6393 else
6399 }
6401 /* Write the tuple out to the new relation */
6409 }
6418 }
6424 {
6430 }
6431 }
6433 /*
6434 * ATGetQueueEntry: find or create an entry in the ALTER TABLE work queue
6435 */
6438 {
6444 {
6448 }
6450 /*
6451 * Not there, so add it. Note that we make a copy of the relation's
6452 * existing descriptor before anything interesting can happen to it.
6453 */
6468 }
6472 {
6474 {
6607 }
6610 }
6612 /*
6613 * ATSimplePermissions
6614 *
6615 * - Ensure that it is a relation (or possibly a view)
6616 * - Ensure this user is the owner
6617 * - Ensure that it is not a system table
6618 */
6619 static void
6621 {
6625 {
6654 }
6656 /* Wrong target type? */
6658 {
6664 /* translator: %s is a group of some SQL keywords */
6668 else
6669 /* internal error? */
6672 }
6674 /* Permissions checks */
6684 }
6686 /*
6687 * ATSimpleRecursion
6688 *
6689 * Simple table recursion sufficient for most ALTER TABLE operations.
6690 * All direct and indirect children are processed in an unspecified order.
6691 * Note that if a child inherits from the original table via multiple
6692 * inheritance paths, it will be visited just once.
6693 */
6694 static void
6698 {
6699 /*
6700 * Propagate to children, if desired and if there are (or might be) any
6701 * children.
6702 */
6704 {
6711 /*
6712 * find_all_inheritors does the recursive search of the inheritance
6713 * hierarchy, so all we have to do is process all of the relids in the
6714 * list that it returns.
6715 */
6717 {
6719 Relation childrel;
6723 /* find_all_inheritors already got lock */
6728 }
6729 }
6730 }
6732 /*
6733 * Obtain list of partitions of the given table, locking them all at the given
6734 * lockmode and ensuring that they all pass CheckTableNotInUse.
6735 *
6736 * This function is a no-op if the given relation is not a partitioned table;
6737 * in particular, nothing is done if it's a legacy inheritance parent.
6738 */
6739 static void
6741 {
6743 {
6748 /* first element is the parent rel; must ignore it */
6750 {
6751 Relation childrel;
6753 /* find_all_inheritors already got lock */
6757 }
6759 }
6760 }
6762 /*
6763 * ATTypedTableRecursion
6764 *
6765 * Propagate ALTER TYPE operations to the typed tables of that type.
6766 * Also check the RESTRICT/CASCADE behavior. Given CASCADE, also permit
6767 * recursion to inheritance children of the typed tables.
6768 */
6769 static void
6772 {
6783 {
6785 Relation childrel;
6791 }
6792 }
6795 /*
6796 * find_composite_type_dependencies
6797 *
6798 * Check to see if the type "typeOid" is being used as a column in some table
6799 * (possibly nested several levels deep in composite types, arrays, etc!).
6800 * Eventually, we'd like to propagate the check or rewrite operation
6801 * into such tables, but for now, just error out if we find any.
6802 *
6803 * Caller should provide either the associated relation of a rowtype,
6804 * or a type name (not both) for use in the error message, if any.
6805 *
6806 * Note that "typeOid" is not necessarily a composite type; it could also be
6807 * another container type such as an array or range, or a domain over one of
6808 * these things. The name of this function is therefore somewhat historical,
6809 * but it's not worth changing.
6810 *
6811 * We assume that functions and views depending on the type are not reasons
6812 * to reject the ALTER. (How safe is this really?)
6813 */
6814 void
6817 {
6818 Relation depRel;
6820 SysScanDesc depScan;
6821 HeapTuple depTup;
6823 /* since this function recurses, it could be driven to stack overflow */
6826 /*
6827 * We scan pg_depend to find those things that depend on the given type.
6828 * (We assume we can ignore refobjsubid for a type.)
6829 */
6833 Anum_pg_depend_refclassid,
6837 Anum_pg_depend_refobjid,
6845 {
6847 Relation rel;
6848 TupleDesc tupleDesc;
6849 Form_pg_attribute att;
6851 /* Check for directly dependent types */
6853 {
6854 /*
6855 * This must be an array, domain, or range containing the given
6856 * type, so recursively check for uses of this type. Note that
6857 * any error message will mention the original type not the
6858 * container; this is intentional.
6859 */
6863 }
6865 /* Else, ignore dependees that aren't relations */
6872 /*
6873 * If objsubid identifies a specific column, refer to that in error
6874 * messages. Otherwise, search to see if there's a user column of the
6875 * type. (We assume system columns are never of interesting types.)
6876 * The search is needed because an index containing an expression
6877 * column of the target type will just be recorded as a whole-relation
6878 * dependency. If we do not find a column of the type, the dependency
6879 * must indicate that the type is transiently referenced in an index
6880 * expression but not stored on disk, which we assume is OK, just as
6881 * we do for references in views. (It could also be that the target
6882 * type is embedded in some container type that is stored in an index
6883 * column, but the previous recursion should catch such cases.)
6884 */
6887 else
6888 {
6891 {
6896 }
6898 {
6899 /* No such column, so assume OK */
6902 }
6903 }
6905 /*
6906 * We definitely should reject if the relation has storage. If it's
6907 * partitioned, then perhaps we don't have to reject: if there are
6908 * partitions then we'll fail when we find one, else there is no
6909 * stored data to worry about. However, it's possible that the type
6910 * change would affect conclusions about whether the type is sortable
6911 * or hashable and thus (if it's a partitioning column) break the
6912 * partitioning rule. For now, reject for partitioned rels too.
6913 */
6916 {
6921 origTypeName,
6938 else
6945 }
6947 {
6948 /*
6949 * A view or composite type itself isn't a problem, but we must
6950 * recursively check for indirect dependencies via its rowtype.
6951 */
6954 }
6957 }
6962 }
6965 /*
6966 * find_typed_table_dependencies
6967 *
6968 * Check to see if a composite type is being used as the type of a
6969 * typed table. Abort if any are found and behavior is RESTRICT.
6970 * Else return the list of tables.
6971 */
6974 {
6975 Relation classRel;
6977 TableScanDesc scan;
6978 HeapTuple tuple;
6984 Anum_pg_class_reloftype,
6991 {
6998 typeName),
7000 else
7002 }
7008 }
7011 /*
7012 * check_of_type
7013 *
7014 * Check whether a type is suitable for CREATE TABLE OF/ALTER TABLE OF. If it
7015 * isn't suitable, throw an error. Currently, we require that the type
7016 * originated with CREATE TYPE AS. We could support any row type, but doing so
7017 * would require handling a number of extra corner cases in the DDL commands.
7018 * (Also, allowing domain-over-composite would open up a can of worms about
7019 * whether and how the domain's constraints should apply to derived tables.)
7020 */
7021 void
7023 {
7028 {
7029 Relation typeRelation;
7035 /*
7036 * Close the parent rel, but keep our AccessShareLock on it until xact
7037 * commit. That will prevent someone else from deleting or ALTERing
7038 * the type before the typed table creation/conversion commits.
7039 */
7041 }
7047 }
7050 /*
7051 * ALTER TABLE ADD COLUMN
7052 *
7053 * Adds an additional attribute to a relation making the assumption that
7054 * CHECK, NOT NULL, and FOREIGN KEY constraints will be removed from the
7055 * AT_AddColumn AlterTableCmd by parse_utilcmd.c and added as independent
7056 * AlterTableCmd's.
7057 *
7058 * ADD COLUMN cannot use the normal ALTER TABLE recursion mechanism, because we
7059 * have to decide at runtime whether to recurse or not depending on whether we
7060 * actually add a column or merely merge with an existing column. (We can't
7061 * check this in a static pre-pass because it won't handle multiple inheritance
7062 * situations correctly.)
7063 */
7064 static void
7068 {
7079 }
7081 /*
7082 * Add a column to a table. The return value is the address of the
7083 * new column in the parent relation.
7084 *
7085 * cmd is pass-by-ref so that we can replace it with the parse-transformed
7086 * copy (but that happens only after we check for IF NOT EXISTS).
7087 */
7088 static ObjectAddress
7093 {
7097 Relation pgclass,
7098 attrdesc;
7099 HeapTuple reltup;
7100 Form_pg_attribute attribute;
7107 ObjectAddress address;
7108 TupleDesc tupdesc;
7110 /* since this function recurses, it could be driven to stack overflow */
7113 /* At top level, permission check was done in ATPrepCmd, else do it */
7124 /*
7125 * Are we adding the column to a recursion child? If so, check whether to
7126 * merge with an existing definition for the column. If we do merge, we
7127 * must not recurse. Children will already have the column, and recursing
7128 * into them would mess up attinhcount.
7129 */
7131 {
7132 HeapTuple tuple;
7134 /* Does child already have a column by this name? */
7137 {
7139 Oid ctypeId;
7140 int32 ctypmod;
7141 Oid ccollid;
7143 /* Child column must match on type, typmod, and collation */
7161 /* Bump the existing child att's inhcount */
7171 /* Inform the user about the merge */
7178 /* Make the child column change visible */
7182 }
7183 }
7185 /* skip if the name already exists and if_not_exists is true */
7187 {
7190 }
7192 /*
7193 * Okay, we need to add the column, so go ahead and do parse
7194 * transformation. This can result in queueing up, or even immediately
7195 * executing, subsidiary operations (such as creation of unique indexes);
7196 * so we mustn't do it until we have made the if_not_exists check.
7197 *
7198 * When recursing, the command was already transformed and we needn't do
7199 * so again. Also, if context isn't given we can't transform. (That
7200 * currently happens only for AT_AddColumnToView; we expect that view.c
7201 * passed us a ColumnDef that doesn't need work.)
7202 */
7204 {
7209 }
7211 /*
7212 * Regular inheritance children are independent enough not to inherit the
7213 * identity column from parent hence cannot recursively add identity
7214 * column if the table has inheritance children.
7215 *
7216 * Partitions, on the other hand, are integral part of a partitioned table
7217 * and inherit identity column. Hence propagate identity column down the
7218 * partition hierarchy.
7219 */
7221 recurse &&
7235 /* Determine the new attribute's number */
7241 MaxHeapAttributeNumber)));
7243 /*
7244 * Construct new attribute's pg_attribute entry.
7245 */
7250 /* Fix up attribute number */
7253 /* make sure datatype is legal for a column */
7262 /*
7263 * Update pg_class tuple as appropriate
7264 */
7271 /* Post creation hook for new attribute */
7276 /* Make the attribute's catalog entry visible */
7279 /*
7280 * Store the DEFAULT, if any, in the catalogs
7281 */
7283 {
7290 /*
7291 * Attempt to skip a complete table rewrite by storing the specified
7292 * DEFAULT value outside of the heap. This may be disabled inside
7293 * AddRelationNewConstraints if the optimization cannot be applied.
7294 */
7299 /*
7300 * This function is intended for CREATE TABLE, so it processes a
7301 * _list_ of defaults, but we just do one.
7302 */
7306 /* Make the additional catalog changes visible */
7309 /*
7310 * Did the request for a missing value work? If not we'll have to do a
7311 * rewrite
7312 */
7315 }
7317 /*
7318 * Tell Phase 3 to fill in the default expression, if there is one.
7319 *
7320 * If there is no default, Phase 3 doesn't have to do anything, because
7321 * that effectively means that the default is NULL. The heap tuple access
7322 * routines always check for attnum > # of attributes in tuple, and return
7323 * NULL if so, so without any modification of the tuple data we will get
7324 * the effect of NULL values in the new column.
7325 *
7326 * An exception occurs when the new column is of a domain type: the domain
7327 * might have a not-null constraint, or a check constraint that indirectly
7328 * rejects nulls. If there are any domain constraints then we construct
7329 * an explicit NULL default value that will be passed through
7330 * CoerceToDomain processing. (This is a tad inefficient, since it causes
7331 * rewriting the table which we really don't have to do, but the present
7332 * design of domain processing doesn't offer any simple way of checking
7333 * the constraints more directly.)
7334 *
7335 * Note: we use build_column_default, and not just the cooked default
7336 * returned by AddRelationNewConstraints, so that the right thing happens
7337 * when a datatype's default applies.
7338 *
7339 * Note: it might seem that this should happen at the end of Phase 2, so
7340 * that the effects of subsequent subcommands can be taken into account.
7341 * It's intentional that we do it now, though. The new column should be
7342 * filled according to what is said in the ADD COLUMN subcommand, so that
7343 * the effects are the same as if this subcommand had been run by itself
7344 * and the later subcommands had been issued in new ALTER TABLE commands.
7345 *
7346 * We can skip this entirely for relations without storage, since Phase 3
7347 * is certainly not going to touch them. System attributes don't have
7348 * interesting defaults, either.
7349 */
7351 {
7352 /*
7353 * For an identity column, we can't use build_column_default(),
7354 * because the sequence ownership isn't set yet. So do it manually.
7355 */
7357 {
7365 /* must do a rewrite for identity columns */
7367 }
7368 else
7372 {
7373 Oid baseTypeId;
7374 int32 baseTypeMod;
7375 Oid baseTypeColl;
7383 baseTypeId,
7386 COERCION_ASSIGNMENT,
7387 COERCE_IMPLICIT_CAST,
7391 }
7394 {
7403 }
7409 {
7410 /*
7411 * If the new column is NOT NULL, and there is no missing value,
7412 * tell Phase 3 it needs to check for NULLs.
7413 */
7415 }
7416 }
7418 /*
7419 * Add needed dependency entries for the new column.
7420 */
7424 /*
7425 * Propagate to children as appropriate. Unlike most other ALTER
7426 * routines, we have to do this one level of recursion at a time; we can't
7427 * use find_all_inheritors to do it in one pass.
7428 */
7429 children =
7432 /*
7433 * If we are told not to recurse, there had better not be any child
7434 * tables; else the addition would put them out of step.
7435 */
7441 /* Children should see column as singly inherited */
7443 {
7448 }
7449 else
7453 {
7455 Relation childrel;
7458 /* find_inheritance_children already got lock */
7462 /* Find or create work queue entry for this table */
7465 /* Recurse to child; return value is ignored */
7471 }
7475 }
7477 /*
7478 * If a new or renamed column will collide with the name of an existing
7479 * column and if_not_exists is false then error out, else do nothing.
7480 */
7481 static bool
7484 {
7485 HeapTuple attTuple;
7488 /*
7489 * this test is deliberately not attisdropped-aware, since if one tries to
7490 * add a column matching a dropped column name, it's gonna fail anyway.
7491 */
7501 /*
7502 * We throw a different error message for conflicts with system column
7503 * names, since they are normally not shown and the user might otherwise
7504 * be confused about the reason for the conflict.
7505 */
7510 colname)));
7511 else
7512 {
7514 {
7520 }
7526 }
7529 }
7531 /*
7532 * Install a column's dependency on its datatype.
7533 */
7534 static void
7536 {
7537 ObjectAddress myself,
7538 referenced;
7547 }
7549 /*
7550 * Install a column's dependency on its collation.
7551 */
7552 static void
7554 {
7555 ObjectAddress myself,
7556 referenced;
7558 /* We know the default collation is pinned, so don't bother recording it */
7560 {
7568 }
7569 }
7571 /*
7572 * ALTER TABLE ALTER COLUMN DROP NOT NULL
7573 *
7574 * Return the address of the modified column. If the column was already
7575 * nullable, InvalidObjectAddress is returned.
7576 */
7577 static ObjectAddress
7579 LOCKMODE lockmode)
7580 {
7581 HeapTuple tuple;
7582 HeapTuple conTup;
7583 Form_pg_attribute attTup;
7584 AttrNumber attnum;
7585 Relation attr_rel;
7586 ObjectAddress address;
7589 /*
7590 * lookup the attribute
7591 */
7605 /* If the column is already nullable there's nothing to do. */
7607 {
7610 }
7612 /* Prevent them from altering a system attribute */
7617 colName)));
7625 /*
7626 * It's not OK to remove a constraint only for the parent and leave it in
7627 * the children, so disallow that.
7628 */
7630 {
7632 {
7633 PartitionDesc partdesc;
7642 }
7645 {
7649 colName),
7651 }
7652 }
7654 /*
7655 * If rel is partition, shouldn't drop NOT NULL if parent has the same.
7656 */
7658 {
7662 AttrNumber parent_attnum;
7669 colName)));
7671 }
7673 /*
7674 * Find the constraint that makes this column NOT NULL, and drop it if we
7675 * see one. dropconstraint_internal() will do necessary consistency
7676 * checking. If there isn't one, there are two possibilities: either the
7677 * column is marked attnotnull because it's part of the primary key, and
7678 * then we just throw an appropriate error; or it's a leftover marking
7679 * that we can remove. However, before doing the latter, to avoid
7680 * breaking consistency any further, prevent this if the column is part of
7681 * the replica identity.
7682 */
7685 {
7689 /*
7690 * If the column is in a primary key, throw a specific error message.
7691 */
7694 pkcols))
7699 /* Also throw an error if the column is in the replica identity */
7707 /* Otherwise, just remove the attnotnull marking and do nothing else. */
7710 }
7711 else
7712 {
7713 /* The normal case: we have a pg_constraint row, remove it */
7719 }
7727 }
7729 /*
7730 * Helper to set pg_attribute.attnotnull if it isn't set, and to tell phase 3
7731 * to verify it; recurses to apply the same to children.
7732 *
7733 * When called to alter an existing table, 'wqueue' must be given so that we can
7734 * queue a check that existing tuples pass the constraint. When called from
7735 * table creation, 'wqueue' should be passed as NULL.
7736 *
7737 * Returns true if the flag was set in any table, otherwise false.
7738 */
7739 static bool
7741 LOCKMODE lockmode)
7742 {
7743 HeapTuple tuple;
7744 Form_pg_attribute attForm;
7747 /* Guard against stack overflow due to overly deep inheritance tree. */
7756 {
7757 Relation attr_rel;
7766 /*
7767 * And set up for existing values to be checked, unless another
7768 * constraint already proves this.
7769 */
7771 {
7776 }
7779 }
7782 {
7786 /* Make above update visible, for multiple inheritance cases */
7792 {
7794 Relation childrel;
7795 AttrNumber childattno;
7797 /* find_inheritance_children already got lock */
7807 }
7808 }
7811 }
7813 /*
7814 * ALTER TABLE ALTER COLUMN SET NOT NULL
7815 *
7816 * Add a not-null constraint to a single table and its children. Returns
7817 * the address of the constraint added to the parent relation, if one gets
7818 * added, or InvalidObjectAddress otherwise.
7819 *
7820 * We must recurse to child tables during execution, rather than using
7821 * ALTER TABLE's normal prep-time recursion.
7822 */
7823 static ObjectAddress
7826 LOCKMODE lockmode)
7827 {
7828 HeapTuple tuple;
7829 Relation constr_rel;
7830 ScanKeyData skey;
7831 SysScanDesc conscan;
7832 AttrNumber attnum;
7833 ObjectAddress address;
7840 /* Guard against stack overflow due to overly deep inheritance tree. */
7843 /*
7844 * In cases of multiple inheritance, we might visit the same child more
7845 * than once. In the topmost call, set up a list that we fill with all
7846 * visited relations, to skip those.
7847 */
7849 {
7852 }
7857 /* At top level, permission check was done in ATPrepCmd, else do it */
7859 {
7862 }
7871 /* Prevent them from altering a system attribute */
7876 colName)));
7878 /* See if there's already a constraint */
7881 Anum_pg_constraint_conrelid,
7888 {
7891 HeapTuple copytup;
7902 /*
7903 * Don't let a NO INHERIT constraint be changed into inherit.
7904 */
7912 /*
7913 * If we find an appropriate constraint, we're almost done, but just
7914 * need to change some properties on it: if we're recursing, increment
7915 * coninhcount; if not, set conislocal if not already set.
7916 */
7918 {
7921 }
7923 {
7926 }
7929 {
7932 }
7939 else
7941 }
7946 /*
7947 * If we're asked not to recurse, and children exist, raise an error for
7948 * partitioned tables. For inheritance, we act as if NO INHERIT had been
7949 * specified.
7950 */
7954 {
7960 else
7962 }
7964 /*
7965 * No constraint exists; we must add one. First determine a name to use,
7966 * if we haven't already.
7967 */
7969 {
7974 NIL);
7975 }
7988 /* and do it */
7997 /*
7998 * Mark pg_attribute.attnotnull for the column. Tell that function not to
7999 * recurse, because we're going to do it here.
8000 */
8003 /*
8004 * Recurse to propagate the constraint to children that don't have one.
8005 */
8007 {
8012 lockmode);
8015 {
8016 Relation childrel;
8025 }
8026 }
8029 }
8031 /*
8032 * ALTER TABLE ALTER COLUMN SET ATTNOTNULL
8033 *
8034 * This doesn't exist in the grammar; it's used when creating a
8035 * primary key and the column is not already marked attnotnull.
8036 */
8037 static ObjectAddress
8040 {
8041 AttrNumber attnum;
8051 /*
8052 * Make the change, if necessary, and only if so report the column as
8053 * changed
8054 */
8060 }
8062 /*
8063 * NotNullImpliedByRelConstraints
8064 * Does rel's existing constraints imply NOT NULL for the given attribute?
8065 */
8066 static bool
8068 {
8079 /*
8080 * argisrow = false is correct even for a composite column, because
8081 * attnotnull does not represent a SQL-spec IS NOT NULL test in such a
8082 * case, just IS DISTINCT FROM NULL.
8083 */
8088 {
8090 (errmsg_internal("existing constraints on column \"%s.%s\" are sufficient to prove that it does not contain nulls",
8093 }
8096 }
8098 /*
8099 * ALTER TABLE ALTER COLUMN SET/DROP DEFAULT
8100 *
8101 * Return the address of the affected column.
8102 */
8103 static ObjectAddress
8106 {
8108 AttrNumber attnum;
8109 ObjectAddress address;
8111 /*
8112 * get the number of the attribute
8113 */
8121 /* Prevent them from altering a system attribute */
8126 colName)));
8133 /* translator: %s is an SQL ALTER command */
8142 newDefault ?
8143 /* translator: %s is an SQL ALTER command */
8148 /*
8149 * Remove any old default for the column. We use RESTRICT here for
8150 * safety, but at present we do not expect anything to depend on the
8151 * default.
8152 *
8153 * We treat removing the existing default as an internal operation when it
8154 * is preparatory to adding a new default, but as a user-initiated
8155 * operation when the user asked for a drop.
8156 */
8161 {
8162 /* SET DEFAULT */
8171 /*
8172 * This function is intended for CREATE TABLE, so it processes a
8173 * _list_ of defaults, but we just do one.
8174 */
8177 }
8182 }
8184 /*
8185 * Add a pre-cooked default expression.
8186 *
8187 * Return the address of the affected column.
8188 */
8189 static ObjectAddress
8192 {
8193 ObjectAddress address;
8195 /* We assume no checking is required */
8197 /*
8198 * Remove any old default for the column. We use RESTRICT here for
8199 * safety, but at present we do not expect anything to depend on the
8200 * default. (In ordinary cases, there could not be a default in place
8201 * anyway, but it's possible when combining LIKE with inheritance.)
8202 */
8211 }
8213 /*
8214 * ALTER TABLE ALTER COLUMN ADD IDENTITY
8215 *
8216 * Return the address of the affected column.
8217 */
8218 static ObjectAddress
8221 {
8222 Relation attrelation;
8223 HeapTuple tuple;
8224 Form_pg_attribute attTup;
8225 AttrNumber attnum;
8226 ObjectAddress address;
8253 /* Can't alter a system attribute */
8258 colName)));
8260 /*
8261 * Creating a column as identity implies NOT NULL, so adding the identity
8262 * to an existing column that is not NOT NULL would create a state that
8263 * cannot be reproduced without contortions.
8264 */
8268 errmsg("column \"%s\" of relation \"%s\" must be declared NOT NULL before identity can be added",
8295 /*
8296 * Recurse to propagate the identity column to partitions. Identity is
8297 * not inherited in regular inheritance children.
8298 */
8300 {
8307 {
8308 Relation childrel;
8313 }
8314 }
8317 }
8319 /*
8320 * ALTER TABLE ALTER COLUMN SET { GENERATED or sequence options }
8321 *
8322 * Return the address of the affected column.
8323 */
8324 static ObjectAddress
8327 {
8330 HeapTuple tuple;
8331 Form_pg_attribute attTup;
8332 AttrNumber attnum;
8333 Relation attrelation;
8334 ObjectAddress address;
8350 {
8354 {
8360 }
8361 else
8364 }
8366 /*
8367 * Even if there is nothing to change here, we run all the checks. There
8368 * will be a subsequent ALTER SEQUENCE that relies on everything being
8369 * there.
8370 */
8387 colName)));
8396 {
8405 }
8406 else
8412 /*
8413 * Recurse to propagate the identity change to partitions. Identity is not
8414 * inherited in regular inheritance children.
8415 */
8417 {
8424 {
8425 Relation childrel;
8430 }
8431 }
8434 }
8436 /*
8437 * ALTER TABLE ALTER COLUMN DROP IDENTITY
8438 *
8439 * Return the address of the affected column.
8440 */
8441 static ObjectAddress
8444 {
8445 HeapTuple tuple;
8446 Form_pg_attribute attTup;
8447 AttrNumber attnum;
8448 Relation attrelation;
8449 ObjectAddress address;
8450 Oid seqid;
8451 ObjectAddress seqaddress;
8481 colName)));
8484 {
8490 else
8491 {
8498 }
8499 }
8513 /*
8514 * Recurse to drop the identity from column in partitions. Identity is
8515 * not inherited in regular inheritance children so ignore them.
8516 */
8518 {
8525 {
8526 Relation childrel;
8531 }
8532 }
8535 {
8536 /* drop the internal sequence */
8545 }
8548 }
8550 /*
8551 * ALTER TABLE ALTER COLUMN SET EXPRESSION
8552 *
8553 * Return the address of the affected column.
8554 */
8555 static ObjectAddress
8558 {
8559 HeapTuple tuple;
8560 Form_pg_attribute attTup;
8561 AttrNumber attnum;
8562 Oid attrdefoid;
8563 ObjectAddress address;
8582 colName)));
8591 /*
8592 * Clear all the missing values if we're rewriting the table, since this
8593 * renders them pointless.
8594 */
8597 /* make sure we don't conflict with later attribute modifications */
8600 /*
8601 * Find everything that depends on the column (constraints, indexes, etc),
8602 * and record enough information to let us recreate the objects after
8603 * rewrite.
8604 */
8607 /*
8608 * Drop the dependency records of the GENERATED expression, in particular
8609 * its INTERNAL dependency on the column, which would otherwise cause
8610 * dependency.c to refuse to perform the deletion.
8611 */
8618 /* Make above changes visible */
8621 /*
8622 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8623 * safety, but at present we do not expect anything to depend on the
8624 * expression.
8625 */
8629 /* Prepare to store the new expression, in the catalogs */
8636 /* Store the generated expression */
8640 /* Make above new expression visible */
8643 /* Prepare for table rewrite */
8654 /* Drop any pg_statistic entry for the column */
8663 }
8665 /*
8666 * ALTER TABLE ALTER COLUMN DROP EXPRESSION
8667 */
8668 static void
8669 ATPrepDropExpression(Relation rel, AlterTableCmd *cmd, bool recurse, bool recursing, LOCKMODE lockmode)
8670 {
8671 /*
8672 * Reject ONLY if there are child tables. We could implement this, but it
8673 * is a bit complicated. GENERATED clauses must be attached to the column
8674 * definition and cannot be added later like DEFAULT, so if a child table
8675 * has a generation expression that the parent does not have, the child
8676 * column will necessarily be an attislocal column. So to implement ONLY
8677 * here, we'd need extra code to update attislocal of the direct child
8678 * tables, somewhat similar to how DROP COLUMN does it, so that the
8679 * resulting state can be properly dumped and restored.
8680 */
8687 /*
8688 * Cannot drop generation expression from inherited columns.
8689 */
8691 {
8692 HeapTuple tuple;
8693 Form_pg_attribute attTup;
8708 }
8709 }
8711 /*
8712 * Return the address of the affected column.
8713 */
8714 static ObjectAddress
8716 {
8717 HeapTuple tuple;
8718 Form_pg_attribute attTup;
8719 AttrNumber attnum;
8720 Relation attrelation;
8721 Oid attrdefoid;
8722 ObjectAddress address;
8739 colName)));
8742 {
8748 else
8749 {
8756 }
8757 }
8759 /*
8760 * Mark the column as no longer generated. (The atthasdef flag needs to
8761 * get cleared too, but RemoveAttrDefault will handle that.)
8762 */
8768 attnum);
8773 /*
8774 * Drop the dependency records of the GENERATED expression, in particular
8775 * its INTERNAL dependency on the column, which would otherwise cause
8776 * dependency.c to refuse to perform the deletion.
8777 */
8784 /* Make above changes visible */
8787 /*
8788 * Get rid of the GENERATED expression itself. We use RESTRICT here for
8789 * safety, but at present we do not expect anything to depend on the
8790 * default.
8791 */
8798 }
8800 /*
8801 * ALTER TABLE ALTER COLUMN SET STATISTICS
8802 *
8803 * Return value is the address of the modified column
8804 */
8805 static ObjectAddress
8806 ATExecSetStatistics(Relation rel, const char *colName, int16 colNum, Node *newValue, LOCKMODE lockmode)
8807 {
8810 Relation attrelation;
8811 HeapTuple tuple,
8812 newtuple;
8813 Form_pg_attribute attrtuple;
8814 AttrNumber attnum;
8815 ObjectAddress address;
8820 /*
8821 * We allow referencing columns by numbers only for indexes, since table
8822 * column numbers could contain gaps if columns are later dropped.
8823 */
8831 /* -1 was used in previous versions for the default setting */
8833 {
8836 }
8837 else
8841 {
8842 /*
8843 * Limit target to a sane range
8844 */
8846 {
8850 newtarget)));
8851 }
8853 {
8858 newtarget)));
8859 }
8860 }
8865 {
8873 }
8874 else
8875 {
8883 }
8892 colName)));
8896 {
8908 }
8910 /* Build new tuple. */
8915 else
8935 }
8937 /*
8938 * Return value is the address of the modified column
8939 */
8940 static ObjectAddress
8943 {
8944 Relation attrelation;
8945 HeapTuple tuple,
8946 newtuple;
8947 Form_pg_attribute attrtuple;
8948 AttrNumber attnum;
8949 Datum datum,
8950 newOptions;
8952 ObjectAddress address;
8973 colName)));
8975 /* Generate new proposed attoptions (text array) */
8981 /* Validate new options */
8984 /* Build new tuple. */
8989 else
8995 /* Update system catalog. */
9011 }
9013 /*
9014 * Helper function for ATExecSetStorage and ATExecSetCompression
9015 *
9016 * Set the attstorage and/or attcompression fields for index columns
9017 * associated with the specified table column.
9018 */
9019 static void
9021 AttrNumber attnum,
9024 LOCKMODE lockmode)
9025 {
9029 {
9031 Relation indrel;
9033 HeapTuple tuple;
9038 {
9040 {
9043 }
9044 }
9047 {
9050 }
9055 {
9071 }
9074 }
9075 }
9077 /*
9078 * ALTER TABLE ALTER COLUMN SET STORAGE
9079 *
9080 * Return value is the address of the modified column
9081 */
9082 static ObjectAddress
9084 {
9085 Relation attrelation;
9086 HeapTuple tuple;
9087 Form_pg_attribute attrtuple;
9088 AttrNumber attnum;
9089 ObjectAddress address;
9107 colName)));
9117 /*
9118 * Apply the change to indexes as well (only for simple index columns,
9119 * matching behavior of index.c ConstructTupleDescriptor()).
9120 */
9124 lockmode);
9133 }
9136 /*
9137 * ALTER TABLE DROP COLUMN
9138 *
9139 * DROP COLUMN cannot use the normal ALTER TABLE recursion mechanism,
9140 * because we have to decide at runtime whether to recurse or not depending
9141 * on whether attinhcount goes to zero or not. (We can't check this in a
9142 * static pre-pass because it won't handle multiple inheritance situations
9143 * correctly.)
9144 */
9145 static void
9149 {
9160 }
9162 /*
9163 * Drops column 'colName' from relation 'rel' and returns the address of the
9164 * dropped column. The column is also dropped (or marked as no longer
9165 * inherited from relation) from the relation's inheritance children, if any.
9166 *
9167 * In the recursive invocations for inheritance child relations, instead of
9168 * dropping the column directly (if to be dropped at all), its object address
9169 * is added to 'addrs', which must be non-NULL in such invocations. All
9170 * columns are dropped at the same time after all the children have been
9171 * checked recursively.
9172 */
9173 static ObjectAddress
9175 DropBehavior behavior,
9179 {
9180 HeapTuple tuple;
9181 Form_pg_attribute targetatt;
9182 AttrNumber attnum;
9184 ObjectAddress object;
9187 /* At top level, permission check was done in ATPrepCmd, else do it */
9191 /* Initialize addrs on the first invocation */
9194 /* since this function recurses, it could be driven to stack overflow */
9200 /*
9201 * get the number of the attribute
9202 */
9205 {
9207 {
9212 }
9213 else
9214 {
9219 }
9220 }
9225 /* Can't drop a system attribute */
9230 colName)));
9232 /*
9233 * Don't drop inherited columns, unless recursing (presumably from a drop
9234 * of the parent column)
9235 */
9240 colName)));
9242 /*
9243 * Don't drop columns used in the partition key, either. (If we let this
9244 * go through, the key column's dependencies would cause a cascaded drop
9245 * of the whole table, which is surely not what the user expected.)
9246 */
9257 /*
9258 * Propagate to children as appropriate. Unlike most other ALTER
9259 * routines, we have to do this one level of recursion at a time; we can't
9260 * use find_all_inheritors to do it in one pass.
9261 */
9262 children =
9266 {
9267 Relation attr_rel;
9270 /*
9271 * In case of a partitioned table, the column must be dropped from the
9272 * partitions as well.
9273 */
9282 {
9284 Relation childrel;
9285 Form_pg_attribute childatt;
9287 /* find_inheritance_children already got lock */
9302 {
9303 /*
9304 * If the child column has other definition sources, just
9305 * decrement its inheritance count; if not, recurse to delete
9306 * it.
9307 */
9309 {
9310 /* Time to delete this child column, too */
9314 }
9315 else
9316 {
9317 /* Child column must survive my deletion */
9322 /* Make update visible */
9324 }
9325 }
9326 else
9327 {
9328 /*
9329 * If we were told to drop ONLY in this table (no recursion),
9330 * we need to mark the inheritors' attributes as locally
9331 * defined rather than inherited.
9332 */
9338 /* Make update visible */
9340 }
9345 }
9347 }
9349 /* Add object to delete */
9356 {
9357 /* Recursion has ended, drop everything that was collected */
9360 }
9363 }
9365 /*
9366 * Prepare to add a primary key on an inheritance parent, by adding NOT NULL
9367 * constraint on its children.
9368 */
9369 static void
9372 {
9377 /* No work if not creating a primary key */
9384 /* No work if no legacy inheritance children are present */
9389 /*
9390 * Acquire locks all the way down the hierarchy. The recursion to lower
9391 * levels occurs at execution time as necessary, so we don't need to do it
9392 * here, and we don't need the returned list either.
9393 */
9396 /*
9397 * Construct the list of constraints that we need to add to each child
9398 * relation.
9399 */
9401 {
9418 }
9420 /* Finally, add AT subcommands to add each constraint to each child. */
9423 {
9432 {
9433 /* ATPrepCmd copies newcmd, so we can scribble on it here */
9438 }
9441 }
9442 }
9444 /*
9445 * ALTER TABLE ADD INDEX
9446 *
9447 * There is no such command in the grammar, but parse_utilcmd.c converts
9448 * UNIQUE and PRIMARY KEY constraints into AT_AddIndex subcommands. This lets
9449 * us schedule creation of the index at the appropriate time during ALTER.
9450 *
9451 * Return value is the address of the new index.
9452 */
9453 static ObjectAddress
9456 {
9460 ObjectAddress address;
9465 /* The IndexStmt has already been through transformIndexStmt */
9468 /* suppress schema rights check when rebuilding existing index */
9470 /* skip index build if phase 3 will do it or we're reusing an old one */
9472 /* suppress notices when rebuilding existing index */
9476 stmt,
9482 check_rights,
9484 skip_build,
9485 quiet);
9487 /*
9488 * If TryReuseIndex() stashed a relfilenumber for us, we used it for the
9489 * new index instead of building from scratch. Restore associated fields.
9490 * This may store InvalidSubTransactionId in both fields, in which case
9491 * relcache.c will assume it can rebuild the relcache entry. Hence, do
9492 * this after the CCI that made catalog rows visible to any rebuild. The
9493 * DROP of the old edition of this index will have scheduled the storage
9494 * for deletion at commit, so cancel that pending deletion.
9495 */
9497 {
9504 }
9507 }
9509 /*
9510 * ALTER TABLE ADD STATISTICS
9511 *
9512 * This is no such command in the grammar, but we use this internally to add
9513 * AT_ReAddStatistics subcommands to rebuild extended statistics after a table
9514 * column type change.
9515 */
9516 static ObjectAddress
9519 {
9520 ObjectAddress address;
9524 /* The CreateStatsStmt has already been through transformStatsStmt */
9530 }
9532 /*
9533 * ALTER TABLE ADD CONSTRAINT USING INDEX
9534 *
9535 * Returns the address of the new constraint.
9536 */
9537 static ObjectAddress
9540 {
9542 Relation indexRel;
9547 ObjectAddress address;
9548 bits16 flags;
9554 /*
9555 * Doing this on partitioned tables is not a simple feature to implement,
9556 * so let's punt for now.
9557 */
9569 /* this should have been checked at parse time */
9573 /*
9574 * Determine name to assign to constraint. We require a constraint to
9575 * have the same name as the underlying index; therefore, use the index's
9576 * existing name as the default constraint name, and if the user
9577 * explicitly gives some other name for the constraint, rename the index
9578 * to match.
9579 */
9584 {
9589 }
9591 /* Extra checks needed if making primary key */
9595 /* Note we currently don't support EXCLUSION constraints here */
9598 else
9601 /* Create the catalog entries for the constraint */
9603 INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
9609 index_oid,
9610 InvalidOid,
9611 indexInfo,
9612 constraintName,
9613 constraintType,
9614 flags,
9615 allowSystemTableMods,
9621 }
9623 /*
9624 * ALTER TABLE ADD CONSTRAINT
9625 *
9626 * Return value is the address of the new constraint; if no constraint was
9627 * added, InvalidObjectAddress is returned.
9628 */
9629 static ObjectAddress
9632 LOCKMODE lockmode)
9633 {
9638 /*
9639 * Currently, we only expect to see CONSTR_CHECK, CONSTR_NOTNULL and
9640 * CONSTR_FOREIGN nodes arriving here (see the preprocessing done in
9641 * parse_utilcmd.c).
9642 */
9644 {
9647 address =
9650 lockmode);
9655 /*
9656 * Assign or validate constraint name
9657 */
9659 {
9668 }
9669 else
9675 NIL);
9678 newConstraint,
9680 lockmode);
9686 }
9689 }
9691 /*
9692 * Generate the column-name portion of the constraint name for a new foreign
9693 * key given the list of column names that reference the referenced
9694 * table. This will be passed to ChooseConstraintName along with the parent
9695 * table name and the "fkey" suffix.
9696 *
9697 * We know that less than NAMEDATALEN characters will actually be used, so we
9698 * can truncate the result once we've generated that many.
9699 *
9700 * XXX see also ChooseExtendedStatisticNameAddition and
9701 * ChooseIndexNameAddition.
9702 */
9705 {
9712 {
9718 /*
9719 * At this point we have buflen <= NAMEDATALEN. name should be less
9720 * than NAMEDATALEN already, but use strlcpy for paranoia.
9721 */
9726 }
9728 }
9730 /*
9731 * Add a check or not-null constraint to a single table and its children.
9732 * Returns the address of the constraint added to the parent relation,
9733 * if one gets added, or InvalidObjectAddress otherwise.
9734 *
9735 * Subroutine for ATExecAddConstraint.
9736 *
9737 * We must recurse to child tables during execution, rather than using
9738 * ALTER TABLE's normal prep-time recursion. The reason is that all the
9739 * constraints *must* be given the same name, else they won't be seen as
9740 * related later. If the user didn't explicitly specify a name, then
9741 * AddRelationNewConstraints would normally assign different names to the
9742 * child constraints. To fix that, we must capture the name assigned at
9743 * the parent table and pass that down.
9744 */
9745 static ObjectAddress
9749 {
9756 /* Guard against stack overflow due to overly deep inheritance tree. */
9759 /* At top level, permission check was done in ATPrepCmd, else do it */
9763 /*
9764 * Call AddRelationNewConstraints to do the work, making sure it works on
9765 * a copy of the Constraint so transformExpr can't modify the original. It
9766 * returns a list of cooked constraints.
9767 *
9768 * If the constraint ends up getting merged with a pre-existing one, it's
9769 * omitted from the returned list, which is what we want: we do not need
9770 * to do any validation work. That can only happen at child tables,
9771 * though, since we disallow merging at the top level.
9772 */
9779 * here */
9781 /* we don't expect more than one constraint here */
9784 /* Add each to-be-validated constraint to Phase 3's queue */
9786 {
9790 {
9799 }
9801 /* Save the actually assigned name if it was defaulted */
9805 /*
9806 * If adding a not-null constraint, set the pg_attribute flag and tell
9807 * phase 3 to verify existing rows, if needed.
9808 */
9814 }
9816 /* At this point we must have a locked-down name to use */
9819 /* Advance command counter in case same table is visited multiple times */
9822 /*
9823 * If the constraint got merged with an existing constraint, we're done.
9824 * We mustn't recurse to child tables in this case, because they've
9825 * already got the constraint, and visiting them again would lead to an
9826 * incorrect value for coninhcount.
9827 */
9831 /*
9832 * If adding a NO INHERIT constraint, no need to find our children.
9833 */
9837 /*
9838 * Propagate to children as appropriate. Unlike most other ALTER
9839 * routines, we have to do this one level of recursion at a time; we can't
9840 * use find_all_inheritors to do it in one pass.
9841 */
9842 children =
9845 /*
9846 * Check if ONLY was specified with ALTER TABLE. If so, allow the
9847 * constraint creation only if there are no children currently. Error out
9848 * otherwise.
9849 */
9855 /*
9856 * The constraint must appear as inherited in children, so create a
9857 * modified constraint object to use.
9858 */
9862 {
9864 Relation childrel;
9867 /* find_inheritance_children already got lock */
9871 /* Find or create work queue entry for this table */
9874 /*
9875 * Recurse to child. XXX if we didn't create a constraint on the
9876 * parent because it already existed, and we do create one on a child,
9877 * should we return that child's constraint ObjectAddress here?
9878 */
9883 }
9886 }
9888 /*
9889 * Add a foreign-key constraint to a single table; return the new constraint's
9890 * address.
9891 *
9892 * Subroutine for ATExecAddConstraint. Must already hold exclusive
9893 * lock on the rel, and have done appropriate validity checks for it.
9894 * We do permissions checks here, however.
9895 *
9896 * When the referenced or referencing tables (or both) are partitioned,
9897 * multiple pg_constraint rows are required -- one for each partitioned table
9898 * and each partition on each side (fortunately, not one for every combination
9899 * thereof). We also need action triggers on each leaf partition on the
9900 * referenced side, and check triggers on each leaf partition on the
9901 * referencing side.
9902 */
9903 static ObjectAddress
9907 {
9908 Relation pkrel;
9922 numpks,
9923 numfkdelsetcols;
9924 Oid indexOid;
9926 ObjectAddress address;
9929 /*
9930 * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
9931 * delete rows out from under us.
9932 */
9935 else
9938 /*
9939 * Validity checks (permission checks wait till we have the column
9940 * numbers)
9941 */
9943 {
9947 errmsg("cannot use ONLY for foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9953 errmsg("cannot add NOT VALID foreign key on partitioned table \"%s\" referencing relation \"%s\"",
9957 }
9972 /*
9973 * References from permanent or unlogged tables to temp tables, and from
9974 * permanent tables to unlogged tables, are disallowed because the
9975 * referenced data can vanish out from under us. References from temp
9976 * tables to any other table type are also disallowed, because other
9977 * backends might need to run the RI triggers on the perm table, but they
9978 * can't reliably see tuples in the local buffers of other backends.
9979 */
9981 {
10005 }
10007 /*
10008 * Look up the referencing attributes to make sure they exist, and record
10009 * their attnums and type OIDs.
10010 */
10027 /*
10028 * If the attribute list for the referenced table was omitted, lookup the
10029 * definition of the primary key and use it. Otherwise, validate the
10030 * supplied attribute list. In either case, discover the index OID and
10031 * index opclasses, and the attnums and type OIDs of the attributes.
10032 */
10034 {
10040 /* If the primary key uses WITHOUT OVERLAPS, the fk must use PERIOD */
10045 }
10046 else
10047 {
10052 /* Since we got pk_attrs, one should be a period. */
10058 /* Look for an index matching the column list */
10061 }
10063 /*
10064 * If the referenced primary key has WITHOUT OVERLAPS, the foreign key
10065 * must use PERIOD.
10066 */
10072 /*
10073 * Now we can check permissions.
10074 */
10077 /*
10078 * Check some things for generated columns.
10079 */
10081 {
10085 {
10086 /*
10087 * Check restrictions on UPDATE/DELETE actions, per SQL standard
10088 */
10102 }
10103 }
10105 /*
10106 * Some actions are currently unsupported for foreign keys using PERIOD.
10107 */
10109 {
10125 }
10127 /*
10128 * Look up the equality operators to use in the constraint.
10129 *
10130 * Note that we have to be careful about the difference between the actual
10131 * PK column type and the opclass' declared input type, which might be
10132 * only binary-compatible with it. The declared opcintype is the right
10133 * thing to probe pg_amop with.
10134 */
10140 /*
10141 * On the strength of a previous constraint, we might avoid scanning
10142 * tables to validate this one. See below.
10143 */
10148 {
10151 Oid fktyped;
10152 HeapTuple cla_ht;
10153 Form_pg_opclass cla_tup;
10154 Oid amid;
10155 Oid opfamily;
10156 Oid opcintype;
10157 Oid pfeqop;
10158 Oid ppeqop;
10159 Oid ffeqop;
10160 int16 eqstrategy;
10161 Oid pfeqop_right;
10163 /* We need several fields out of the pg_opclass entry */
10174 {
10175 StrategyNumber rtstrategy;
10178 /*
10179 * GiST indexes are required to support temporal foreign keys
10180 * because they combine equals and overlaps.
10181 */
10187 /*
10188 * An opclass can use whatever strategy numbers it wants, so we
10189 * ask the opclass what number it actually uses instead of our RT*
10190 * constants.
10191 */
10194 {
10195 HeapTuple tuple;
10203 for_overlaps
10206 errdetail("Could not translate strategy number %d for operator class \"%s\" for access method \"%s\".",
10208 }
10209 }
10210 else
10211 {
10212 /*
10213 * Check it's a btree; currently this can never fail since no
10214 * other index AMs support unique indexes. If we ever did have
10215 * other types of unique indexes, we'd need a way to determine
10216 * which operator strategy number is equality. (We could use
10217 * something like GistTranslateStratnum.)
10218 */
10222 }
10224 /*
10225 * There had better be a primary equality operator for the index.
10226 * We'll use it for PK = PK comparisons.
10227 */
10229 eqstrategy);
10235 /*
10236 * Are there equality operators that take exactly the FK type? Assume
10237 * we should look through any domain here.
10238 */
10242 eqstrategy);
10244 {
10247 eqstrategy);
10248 }
10249 else
10250 {
10251 /* keep compiler quiet */
10254 }
10257 {
10258 /*
10259 * Otherwise, look for an implicit cast from the FK type to the
10260 * opcintype, and if found, use the primary equality operator.
10261 * This is a bit tricky because opcintype might be a polymorphic
10262 * type such as ANYARRAY or ANYENUM; so what we have to test is
10263 * whether the two actual column types can be concurrently cast to
10264 * that type. (Otherwise, we'd fail to reject combinations such
10265 * as int[] and point[].)
10266 */
10275 COERCION_IMPLICIT))
10276 {
10279 }
10280 }
10295 {
10296 /*
10297 * When a pfeqop changes, revalidate the constraint. We could
10298 * permit intra-opfamily changes, but that adds subtle complexity
10299 * without any concrete benefit for core types. We need not
10300 * assess ppeqop or ffeqop, which RI_Initial_Check() does not use.
10301 */
10304 old_pfeqop_item);
10305 }
10307 {
10308 Oid old_fktype;
10309 Oid new_fktype;
10310 CoercionPathType old_pathtype;
10311 CoercionPathType new_pathtype;
10312 Oid old_castfunc;
10313 Oid new_castfunc;
10317 /*
10318 * Identify coercion pathways from each of the old and new FK-side
10319 * column types to the right (foreign) operand type of the pfeqop.
10320 * We may assume that pg_constraint.conkey is not changing.
10321 */
10329 /*
10330 * Upon a change to the cast from the FK column to its pfeqop
10331 * operand, revalidate the constraint. For this evaluation, a
10332 * binary coercion cast is equivalent to no cast at all. While
10333 * type implementors should design implicit casts with an eye
10334 * toward consistency of operations like equality, we cannot
10335 * assume here that they have done so.
10336 *
10337 * A function with a polymorphic argument could change behavior
10338 * arbitrarily in response to get_fn_expr_argtype(). Therefore,
10339 * when the cast destination is polymorphic, we only avoid
10340 * revalidation if the input type has not changed at all. Given
10341 * just the core data types and operator classes, this requirement
10342 * prevents no would-be optimizations.
10343 *
10344 * If the cast converts from a base type to a domain thereon, then
10345 * that domain type must be the opcintype of the unique index.
10346 * Necessarily, the primary key column must then be of the domain
10347 * type. Since the constraint was previously valid, all values on
10348 * the foreign side necessarily exist on the primary side and in
10349 * turn conform to the domain. Consequently, we need not treat
10350 * domains specially here.
10351 *
10352 * Since we require that all collations share the same notion of
10353 * equality (which they do, because texteq reduces to bitwise
10354 * equality), we don't compare collation here.
10355 *
10356 * We need not directly consider the PK type. It's necessarily
10357 * binary coercible to the opcintype of the unique index column,
10358 * and ri_triggers.c will only deal with PK datums in terms of
10359 * that opcintype. Changing the opcintype also changes pfeqop.
10360 */
10365 }
10370 }
10372 /*
10373 * For FKs with PERIOD we need additional operators to check whether the
10374 * referencing row's range is contained by the aggregated ranges of the
10375 * referenced row(s). For rangetypes and multirangetypes this is
10376 * fk.periodatt <@ range_agg(pk.periodatt). Those are the only types we
10377 * support for now. FKs will look these up at "runtime", but we should
10378 * make sure the lookup works here, even if we don't use the values.
10379 */
10381 {
10382 Oid periodoperoid;
10383 Oid aggedperiodoperoid;
10386 }
10388 /*
10389 * Create all the constraint and trigger objects, recursing to partitions
10390 * as necessary. First handle the referenced side.
10391 */
10393 indexOid,
10395 numfks,
10396 pkattnum,
10397 fkattnum,
10398 pfeqoperators,
10399 ppeqoperators,
10400 ffeqoperators,
10401 numfkdelsetcols,
10402 fkdelsetcols,
10403 old_check_ok,
10405 with_period);
10407 /* Now handle the referencing side. */
10409 indexOid,
10411 numfks,
10412 pkattnum,
10413 fkattnum,
10414 pfeqoperators,
10415 ppeqoperators,
10416 ffeqoperators,
10417 numfkdelsetcols,
10418 fkdelsetcols,
10419 old_check_ok,
10420 lockmode,
10422 with_period);
10424 /*
10425 * Done. Close pk table, but keep lock until we've committed.
10426 */
10430 }
10432 /*
10433 * validateFkOnDeleteSetColumns
10434 * Verifies that columns used in ON DELETE SET NULL/DEFAULT (...)
10435 * column lists are valid.
10436 */
10437 void
10441 {
10443 {
10448 {
10450 {
10453 }
10454 }
10457 {
10462 errmsg("column \"%s\" referenced in ON DELETE SET action must be part of foreign key", col)));
10463 }
10464 }
10465 }
10467 /*
10468 * addFkRecurseReferenced
10469 * subroutine for ATAddForeignKeyConstraint; recurses on the referenced
10470 * side of the constraint
10471 *
10472 * Create pg_constraint rows for the referenced side of the constraint,
10473 * referencing the parent of the referencing side; also create action triggers
10474 * on leaf partitions. If the table is partitioned, recurse to handle each
10475 * partition.
10476 *
10477 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10478 * of an ALTER TABLE sequence.
10479 * fkconstraint is the constraint being added.
10480 * rel is the root referencing relation.
10481 * pkrel is the referenced relation; might be a partition, if recursing.
10482 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10483 * parentConstr is the OID of a parent constraint; InvalidOid if this is a
10484 * top-level constraint.
10485 * numfks is the number of columns in the foreign key
10486 * pkattnum is the attnum array of referenced attributes.
10487 * fkattnum is the attnum array of referencing attributes.
10488 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10489 * (...) clause
10490 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10491 * NULL/DEFAULT clause
10492 * pf/pp/ffeqoperators are OID array of operators between columns.
10493 * old_check_ok signals that this constraint replaces an existing one that
10494 * was already validated (thus this one doesn't need validation).
10495 * parentDelTrigger and parentUpdTrigger, when being recursively called on
10496 * a partition, are the OIDs of the parent action triggers for DELETE and
10497 * UPDATE respectively.
10498 */
10499 static ObjectAddress
10509 {
10510 ObjectAddress address;
10511 Oid constrOid;
10516 Oid deleteTriggerOid,
10517 updateTriggerOid;
10519 /*
10520 * Verify relkind for each referenced partition. At the top level, this
10521 * is redundant with a previous check, but we need it when recursing.
10522 */
10530 /*
10531 * Caller supplies us with a constraint name; however, it may be used in
10532 * this partition, so come up with a different one in that case.
10533 */
10541 else
10545 {
10549 }
10550 else
10551 {
10555 /*
10556 * always inherit for partitioned tables, never for legacy inheritance
10557 */
10559 }
10561 /*
10562 * Record the FK constraint in pg_constraint.
10563 */
10566 CONSTRAINT_FOREIGN,
10570 parentConstr,
10572 fkattnum,
10573 numfks,
10574 numfks,
10576 indexOid,
10578 pkattnum,
10579 pfeqoperators,
10580 ppeqoperators,
10581 ffeqoperators,
10582 numfks,
10585 fkdelsetcols,
10586 numfkdelsetcols,
10590 NULL,
10599 /*
10600 * Mark the child constraint as part of the parent constraint; it must not
10601 * be dropped on its own. (This constraint is deleted when the partition
10602 * is detached, but a special check needs to occur that the partition
10603 * contains no referenced values.)
10604 */
10606 {
10607 ObjectAddress referenced;
10611 }
10613 /* make new constraint visible, in case we add more */
10616 /*
10617 * Create the action triggers that enforce the constraint.
10618 */
10620 fkconstraint,
10625 /*
10626 * If the referenced table is partitioned, recurse on ourselves to handle
10627 * each partition. We need one pg_constraint row created for each
10628 * partition in addition to the pg_constraint row for the parent table.
10629 */
10631 {
10635 {
10636 Relation partRel;
10639 Oid partIndexId;
10643 /*
10644 * Map the attribute numbers in the referenced side of the FK
10645 * definition to match the partition's column layout.
10646 */
10651 {
10655 }
10656 else
10659 /* do the deed */
10669 old_check_ok,
10671 with_period);
10673 /* Done -- clean up (but keep the lock) */
10676 {
10679 }
10680 }
10681 }
10684 }
10686 /*
10687 * addFkRecurseReferencing
10688 * subroutine for ATAddForeignKeyConstraint and CloneFkReferencing
10689 *
10690 * If the referencing relation is a plain relation, create the necessary check
10691 * triggers that implement the constraint, and set up for Phase 3 constraint
10692 * verification. If the referencing relation is a partitioned table, then
10693 * we create a pg_constraint row for it and recurse on this routine for each
10694 * partition.
10695 *
10696 * We assume that the referenced relation is locked against concurrent
10697 * deletions. If it's a partitioned relation, every partition must be so
10698 * locked.
10699 *
10700 * wqueue is the ALTER TABLE work queue; can be NULL when not running as part
10701 * of an ALTER TABLE sequence.
10702 * fkconstraint is the constraint being added.
10703 * rel is the referencing relation; might be a partition, if recursing.
10704 * pkrel is the root referenced relation.
10705 * indexOid is the OID of the index (on pkrel) implementing this constraint.
10706 * parentConstr is the OID of the parent constraint (there is always one).
10707 * numfks is the number of columns in the foreign key
10708 * pkattnum is the attnum array of referenced attributes.
10709 * fkattnum is the attnum array of referencing attributes.
10710 * pf/pp/ffeqoperators are OID array of operators between columns.
10711 * numfkdelsetcols is the number of columns in the ON DELETE SET NULL/DEFAULT
10712 * (...) clause
10713 * fkdelsetcols is the attnum array of the columns in the ON DELETE SET
10714 * NULL/DEFAULT clause
10715 * old_check_ok signals that this constraint replaces an existing one that
10716 * was already validated (thus this one doesn't need validation).
10717 * lockmode is the lockmode to acquire on partitions when recursing.
10718 * parentInsTrigger and parentUpdTrigger, when being recursively called on
10719 * a partition, are the OIDs of the parent check triggers for INSERT and
10720 * UPDATE respectively.
10721 */
10722 static void
10731 {
10732 Oid insertTriggerOid,
10733 updateTriggerOid;
10742 /*
10743 * Add the check triggers to it and, if necessary, schedule it to be
10744 * checked in Phase 3.
10745 *
10746 * If the relation is partitioned, drill down to do it to its partitions.
10747 */
10750 fkconstraint,
10751 parentConstr,
10752 indexOid,
10757 {
10758 /*
10759 * Tell Phase 3 to check that the constraint is satisfied by existing
10760 * rows. We can skip this during table creation, when requested
10761 * explicitly by specifying NOT VALID in an ADD FOREIGN KEY command,
10762 * and when we're recreating a constraint following a SET DATA TYPE
10763 * operation that did not impugn its validity.
10764 */
10766 {
10782 }
10783 }
10785 {
10787 Relation trigrel;
10789 /*
10790 * Triggers of the foreign keys will be manipulated a bunch of times
10791 * in the loop below. To avoid repeatedly opening/closing the trigger
10792 * catalog relation, we open it here and pass it to the subroutines
10793 * called below.
10794 */
10797 /*
10798 * Recurse to take appropriate action on each partition; either we
10799 * find an existing constraint to reparent to ours, or we create a new
10800 * one.
10801 */
10803 {
10811 Oid constrOid;
10812 ObjectAddress address,
10813 referenced;
10824 /* Check whether an existing constraint can be repurposed */
10828 {
10833 partitionId,
10834 parentConstr,
10835 numfks,
10836 mapped_fkattnum,
10837 pkattnum,
10838 pfeqoperators,
10839 insertTriggerOid,
10840 updateTriggerOid,
10841 trigrel))
10842 {
10845 }
10846 }
10848 {
10851 }
10853 /*
10854 * No luck finding a good constraint to reuse; create our own.
10855 */
10863 else
10865 constrOid =
10868 CONSTRAINT_FOREIGN,
10872 parentConstr,
10873 partitionId,
10874 mapped_fkattnum,
10875 numfks,
10876 numfks,
10877 InvalidOid,
10878 indexOid,
10880 pkattnum,
10881 pfeqoperators,
10882 ppeqoperators,
10883 ffeqoperators,
10884 numfks,
10887 fkdelsetcols,
10888 numfkdelsetcols,
10890 NULL,
10891 NULL,
10892 NULL,
10899 /*
10900 * Give this constraint partition-type dependencies on the parent
10901 * constraint as well as the table.
10902 */
10909 /* Make all this visible before recursing */
10912 /* call ourselves to finalize the creation and we're done */
10914 indexOid,
10915 constrOid,
10916 numfks,
10917 pkattnum,
10918 mapped_fkattnum,
10919 pfeqoperators,
10920 ppeqoperators,
10921 ffeqoperators,
10922 numfkdelsetcols,
10923 fkdelsetcols,
10924 old_check_ok,
10925 lockmode,
10926 insertTriggerOid,
10927 updateTriggerOid,
10928 with_period);
10931 }
10934 }
10935 }
10937 /*
10938 * CloneForeignKeyConstraints
10939 * Clone foreign keys from a partitioned table to a newly acquired
10940 * partition.
10941 *
10942 * partitionRel is a partition of parentRel, so we can be certain that it has
10943 * the same columns with the same datatypes. The columns may be in different
10944 * order, though.
10945 *
10946 * wqueue must be passed to set up phase 3 constraint checking, unless the
10947 * referencing-side partition is known to be empty (such as in CREATE TABLE /
10948 * PARTITION OF).
10949 */
10950 static void
10952 Relation partitionRel)
10953 {
10954 /* This only works for declarative partitioning */
10957 /*
10958 * Clone constraints for which the parent is on the referenced side.
10959 */
10962 /*
10963 * Now clone constraints where the parent is on the referencing side.
10964 */
10966 }
10968 /*
10969 * CloneFkReferenced
10970 * Subroutine for CloneForeignKeyConstraints
10971 *
10972 * Find all the FKs that have the parent relation on the referenced side;
10973 * clone those constraints to the given partition. This is to be called
10974 * when the partition is being created or attached.
10975 *
10976 * This ignores self-referencing FKs; those are handled by CloneFkReferencing.
10977 *
10978 * This recurses to partitions, if the relation being attached is partitioned.
10979 * Recursion is done by calling addFkRecurseReferenced.
10980 */
10981 static void
10983 {
10984 Relation pg_constraint;
10987 SysScanDesc scan;
10989 HeapTuple tuple;
10991 Relation trigrel;
10993 /*
10994 * Search for any constraints where this partition's parent is in the
10995 * referenced side. However, we must not clone any constraint whose
10996 * parent constraint is also going to be cloned, to avoid duplicates. So
10997 * do it in two steps: first construct the list of constraints to clone,
10998 * then go over that list cloning those whose parents are not in the list.
10999 * (We must not rely on the parent being seen first, since the catalog
11000 * scan could return children first.)
11001 */
11009 /* This is a seqscan, as we don't have a usable index ... */
11013 {
11017 }
11021 /*
11022 * Triggers of the foreign keys will be manipulated a bunch of times in
11023 * the loop below. To avoid repeatedly opening/closing the trigger
11024 * catalog relation, we open it here and pass it to the subroutines called
11025 * below.
11026 */
11033 {
11035 Form_pg_constraint constrForm;
11036 Relation fkRel;
11037 Oid indexOid;
11038 Oid partIndexId;
11049 Oid deleteTriggerOid,
11050 updateTriggerOid;
11057 /*
11058 * As explained above: don't try to clone a constraint for which we're
11059 * going to clone the parent.
11060 */
11062 {
11065 }
11067 /*
11068 * Don't clone self-referencing foreign keys, which can be in the
11069 * partitioned table or in the partition-to-be.
11070 */
11073 {
11076 }
11078 /*
11079 * Because we're only expanding the key space at the referenced side,
11080 * we don't need to prevent any operation in the referencing table, so
11081 * AccessShareLock suffices (assumes that dropping the constraint
11082 * acquires AEL).
11083 */
11089 conkey,
11090 confkey,
11091 conpfeqop,
11092 conppeqop,
11093 conffeqop,
11095 confdelsetcols);
11107 /* ->fk_attrs determined below */
11118 /* set up colnames that are used to generate the constraint name */
11120 {
11121 Form_pg_attribute att;
11127 }
11129 /*
11130 * Add the new foreign key constraint pointing to the new partition.
11131 * Because this new partition appears in the referenced side of the
11132 * constraint, we don't need to set up for Phase 3 check.
11133 */
11139 /*
11140 * Get the "action" triggers belonging to the constraint to pass as
11141 * parent OIDs for similar triggers that will be created on the
11142 * partition in addFkRecurseReferenced().
11143 */
11149 fkconstraint,
11150 fkRel,
11151 partitionRel,
11152 partIndexId,
11153 constrOid,
11154 numfks,
11155 mapped_confkey,
11156 conkey,
11157 conpfeqop,
11158 conppeqop,
11159 conffeqop,
11160 numfkdelsetcols,
11161 confdelsetcols,
11163 deleteTriggerOid,
11164 updateTriggerOid,
11169 }
11172 }
11174 /*
11175 * CloneFkReferencing
11176 * Subroutine for CloneForeignKeyConstraints
11177 *
11178 * For each FK constraint of the parent relation in the given list, find an
11179 * equivalent constraint in its partition relation that can be reparented;
11180 * if one cannot be found, create a new constraint in the partition as its
11181 * child.
11182 *
11183 * If wqueue is given, it is used to set up phase-3 verification for each
11184 * cloned constraint; if omitted, we assume that such verification is not
11185 * needed (example: the partition is being created anew).
11186 */
11187 static void
11189 {
11194 Relation trigrel;
11196 /* obtain a list of constraints that we need to clone */
11198 {
11202 }
11204 /*
11205 * Silently do nothing if there's nothing to do. In particular, this
11206 * avoids throwing a spurious error for foreign tables.
11207 */
11216 /*
11217 * Triggers of the foreign keys will be manipulated a bunch of times in
11218 * the loop below. To avoid repeatedly opening/closing the trigger
11219 * catalog relation, we open it here and pass it to the subroutines called
11220 * below.
11221 */
11224 /*
11225 * The constraint key may differ, if the columns in the partition are
11226 * different. This map is used to convert them.
11227 */
11235 {
11237 Form_pg_constraint constrForm;
11238 Relation pkrel;
11239 HeapTuple tuple;
11251 Oid indexOid;
11252 Oid constrOid;
11253 ObjectAddress address,
11254 referenced;
11256 Oid insertTriggerOid,
11257 updateTriggerOid;
11263 parentConstrOid);
11266 /* Don't clone constraints whose parents are being cloned */
11268 {
11271 }
11273 /*
11274 * Need to prevent concurrent deletions. If pkrel is a partitioned
11275 * relation, that means to lock all partitions.
11276 */
11288 /*
11289 * Get the "check" triggers belonging to the constraint to pass as
11290 * parent OIDs for similar triggers that will be created on the
11291 * partition in addFkRecurseReferencing(). They are also passed to
11292 * tryAttachPartitionForeignKey() below to simply assign as parents to
11293 * the partition's existing "check" triggers, that is, if the
11294 * corresponding constraints is deemed attachable to the parent
11295 * constraint.
11296 */
11301 /*
11302 * Before creating a new constraint, see whether any existing FKs are
11303 * fit for the purpose. If one is, attach the parent constraint to
11304 * it, and don't clone anything. This way we avoid the expensive
11305 * verification step and don't end up with a duplicate FK, and we
11306 * don't need to recurse to partitions for this constraint.
11307 */
11310 {
11315 parentConstrOid,
11316 numfks,
11317 mapped_conkey,
11318 confkey,
11319 conpfeqop,
11320 insertTriggerOid,
11321 updateTriggerOid,
11322 trigrel))
11323 {
11327 }
11328 }
11330 {
11333 }
11335 /* No dice. Set up to create our own constraint */
11338 /* ->conname determined below */
11343 /* ->fk_attrs determined below */
11354 {
11355 Form_pg_attribute att;
11361 }
11370 else
11375 constrOid =
11378 CONSTRAINT_FOREIGN,
11382 parentConstrOid,
11384 mapped_conkey,
11385 numfks,
11386 numfks,
11388 indexOid,
11390 confkey,
11391 conpfeqop,
11392 conppeqop,
11393 conffeqop,
11394 numfks,
11397 confdelsetcols,
11398 numfkdelsetcols,
11400 NULL,
11401 NULL,
11402 NULL,
11409 /* Set up partition dependencies for the new constraint */
11417 /* Done with the cloned constraint's tuple */
11420 /* Make all this visible before recursing */
11424 fkconstraint,
11425 partRel,
11426 pkrel,
11427 indexOid,
11428 constrOid,
11429 numfks,
11430 confkey,
11431 mapped_conkey,
11432 conpfeqop,
11433 conppeqop,
11434 conffeqop,
11435 numfkdelsetcols,
11436 confdelsetcols,
11438 AccessExclusiveLock,
11439 insertTriggerOid,
11440 updateTriggerOid,
11441 with_period);
11443 }
11446 }
11448 /*
11449 * When the parent of a partition receives [the referencing side of] a foreign
11450 * key, we must propagate that foreign key to the partition. However, the
11451 * partition might already have an equivalent foreign key; this routine
11452 * compares the given ForeignKeyCacheInfo (in the partition) to the FK defined
11453 * by the other parameters. If they are equivalent, create the link between
11454 * the two constraints and return true.
11455 *
11456 * If the given FK does not match the one defined by rest of the params,
11457 * return false.
11458 */
11459 static bool
11461 Oid partRelid,
11462 Oid parentConstrOid,
11467 Oid parentInsTrigger,
11468 Oid parentUpdTrigger,
11469 Relation trigrel)
11470 {
11471 HeapTuple parentConstrTup;
11472 Form_pg_constraint parentConstr;
11473 HeapTuple partcontup;
11474 Form_pg_constraint partConstr;
11475 ScanKeyData key;
11476 SysScanDesc scan;
11477 HeapTuple trigtup;
11478 Oid insertTriggerOid,
11479 updateTriggerOid;
11487 /*
11488 * Do some quick & easy initial checks. If any of these fail, we cannot
11489 * use this constraint.
11490 */
11492 {
11495 }
11497 {
11501 {
11504 }
11505 }
11507 /*
11508 * Looks good so far; do some more extensive checks. Presumably the check
11509 * for 'convalidated' could be dropped, since we don't really care about
11510 * that, but let's be careful for now.
11511 */
11524 {
11528 }
11533 /*
11534 * Looks good! Attach this constraint. The action triggers in the new
11535 * partition become redundant -- the parent table already has equivalent
11536 * ones, and those will be able to reach the partition. Remove the ones
11537 * in the partition. We identify them because they have our constraint
11538 * OID, as well as being on the referenced rel.
11539 */
11541 Anum_pg_trigger_tgconstraint,
11547 {
11549 ObjectAddress trigger;
11556 /*
11557 * The constraint is originally set up to contain this trigger as an
11558 * implementation object, so there's a dependency record that links
11559 * the two; however, since the trigger is no longer needed, we remove
11560 * the dependency link in order to be able to drop the trigger while
11561 * keeping the constraint intact.
11562 */
11566 /* make dependency deletion visible to performDeletion */
11571 /* make trigger drop visible, in case the loop iterates */
11573 }
11579 /*
11580 * Like the constraint, attach partition's "check" triggers to the
11581 * corresponding parent triggers.
11582 */
11588 partRelid);
11591 partRelid);
11595 }
11597 /*
11598 * GetForeignKeyActionTriggers
11599 * Returns delete and update "action" triggers of the given relation
11600 * belonging to the given constraint
11601 */
11602 static void
11607 {
11608 ScanKeyData key;
11609 SysScanDesc scan;
11610 HeapTuple trigtup;
11614 Anum_pg_trigger_tgconstraint,
11621 {
11628 /* Only ever look at "action" triggers on the PK side. */
11632 {
11635 }
11637 {
11640 }
11641 #ifndef USE_ASSERT_CHECKING
11642 /* In an assert-enabled build, continue looking to find duplicates */
11645 #endif
11646 }
11650 conoid);
11653 conoid);
11656 }
11658 /*
11659 * GetForeignKeyCheckTriggers
11660 * Returns insert and update "check" triggers of the given relation
11661 * belonging to the given constraint
11662 */
11663 static void
11668 {
11669 ScanKeyData key;
11670 SysScanDesc scan;
11671 HeapTuple trigtup;
11675 Anum_pg_trigger_tgconstraint,
11682 {
11689 /* Only ever look at "check" triggers on the FK side. */
11693 {
11696 }
11698 {
11701 }
11702 #ifndef USE_ASSERT_CHECKING
11703 /* In an assert-enabled build, continue looking to find duplicates. */
11706 #endif
11707 }
11711 conoid);
11714 conoid);
11717 }
11719 /*
11720 * ALTER TABLE ALTER CONSTRAINT
11721 *
11722 * Update the attributes of a constraint.
11723 *
11724 * Currently only works for Foreign Key constraints.
11725 *
11726 * If the constraint is modified, returns its address; otherwise, return
11727 * InvalidObjectAddress.
11728 */
11729 static ObjectAddress
11732 {
11734 Relation conrel;
11735 Relation tgrel;
11736 SysScanDesc scan;
11738 HeapTuple contuple;
11739 Form_pg_constraint currcon;
11740 ObjectAddress address;
11749 /*
11750 * Find and check the target constraint
11751 */
11753 Anum_pg_constraint_conrelid,
11757 Anum_pg_constraint_contypid,
11761 Anum_pg_constraint_conname,
11767 /* There can be at most one matching row */
11781 /*
11782 * If it's not the topmost constraint, raise an error.
11783 *
11784 * Altering a non-topmost constraint leaves some triggers untouched, since
11785 * they are not directly connected to this constraint; also, pg_dump would
11786 * ignore the deferrability status of the individual constraint, since it
11787 * only dumps topmost constraints. Avoid these problems by refusing this
11788 * operation and telling the user to alter the parent constraint instead.
11789 */
11791 {
11792 HeapTuple tp;
11797 /* Loop to find the topmost constraint */
11799 {
11802 /* If no parent, this is the constraint we want */
11804 {
11809 }
11813 }
11822 }
11824 /*
11825 * Do the actual catalog work. We can skip changing if already in the
11826 * desired state, but not if a partitioned table: partitions need to be
11827 * processed regardless, in case they had the constraint locally changed.
11828 */
11833 {
11837 }
11839 /*
11840 * ATExecAlterConstrRecurse already invalidated relcache for the relations
11841 * having the constraint itself; here we also invalidate for relations
11842 * that have any triggers that are part of the constraint.
11843 */
11853 }
11855 /*
11856 * Recursive subroutine of ATExecAlterConstraint. Returns true if the
11857 * constraint is altered.
11858 *
11859 * *otherrelids is appended OIDs of relations containing affected triggers.
11860 *
11861 * Note that we must recurse even when the values are correct, in case
11862 * indirect descendants have had their constraints altered locally.
11863 * (This could be avoided if we forbade altering constraints in partitions
11864 * but existing releases don't do that.)
11865 */
11866 static bool
11869 LOCKMODE lockmode)
11870 {
11871 Form_pg_constraint currcon;
11872 Oid conoid;
11873 Oid refrelid;
11876 /* since this function recurses, it could be driven to stack overflow */
11883 /*
11884 * Update pg_constraint with the flags from cmdcon.
11885 *
11886 * If called to modify a constraint that's already in the desired state,
11887 * silently do nothing.
11888 */
11891 {
11892 HeapTuple copyTuple;
11893 Form_pg_constraint copy_con;
11894 HeapTuple tgtuple;
11895 ScanKeyData tgkey;
11896 SysScanDesc tgscan;
11910 /* Make new constraint flags visible to others */
11913 /*
11914 * Now we need to update the multiple entries in pg_trigger that
11915 * implement the constraint.
11916 */
11918 Anum_pg_trigger_tgconstraint,
11924 {
11926 Form_pg_trigger copy_tg;
11927 HeapTuple tgCopyTuple;
11929 /*
11930 * Remember OIDs of other relation(s) involved in FK constraint.
11931 * (Note: it's likely that we could skip forcing a relcache inval
11932 * for other rels that don't have a trigger whose properties
11933 * change, but let's be conservative.)
11934 */
11939 /*
11940 * Update deferrability of RI_FKey_noaction_del,
11941 * RI_FKey_noaction_upd, RI_FKey_check_ins and RI_FKey_check_upd
11942 * triggers, but not others; see createForeignKeyActionTriggers
11943 * and CreateFKCheckTrigger.
11944 */
11961 }
11964 }
11966 /*
11967 * If the table at either end of the constraint is partitioned, we need to
11968 * recurse and handle every constraint that is a child of this one.
11969 *
11970 * (This assumes that the recurse flag is forcibly set for partitioned
11971 * tables, and not set for legacy inheritance, though we don't check for
11972 * that here.)
11973 */
11976 {
11977 ScanKeyData pkey;
11978 SysScanDesc pscan;
11979 HeapTuple childtup;
11982 Anum_pg_constraint_conparentid,
11990 {
11992 Relation childrel;
11998 }
12001 }
12004 }
12006 /*
12007 * ALTER TABLE VALIDATE CONSTRAINT
12008 *
12009 * XXX The reason we handle recursion here rather than at Phase 1 is because
12010 * there's no good way to skip recursing when handling foreign keys: there is
12011 * no need to lock children in that case, yet we wouldn't be able to avoid
12012 * doing so at that level.
12013 *
12014 * Return value is the address of the validated constraint. If the constraint
12015 * was already validated, InvalidObjectAddress is returned.
12016 */
12017 static ObjectAddress
12020 {
12021 Relation conrel;
12022 SysScanDesc scan;
12024 HeapTuple tuple;
12025 Form_pg_constraint con;
12026 ObjectAddress address;
12030 /*
12031 * Find and check the target constraint
12032 */
12034 Anum_pg_constraint_conrelid,
12038 Anum_pg_constraint_contypid,
12042 Anum_pg_constraint_conname,
12048 /* There can be at most one matching row */
12064 {
12066 HeapTuple copyTuple;
12067 Form_pg_constraint copy_con;
12070 {
12074 /* Queue validation for phase 3 */
12076 /* for now this is all we need */
12087 /* Find or create work queue entry for this table */
12091 /*
12092 * We disallow creating invalid foreign keys to or from
12093 * partitioned tables, so ignoring the recursion bit is okay.
12094 */
12095 }
12097 {
12101 Datum val;
12104 /*
12105 * If we're recursing, the parent has already done this, so skip
12106 * it. Also, if the constraint is a NO INHERIT constraint, we
12107 * shouldn't try to look for it in the children.
12108 */
12113 /*
12114 * For CHECK constraints, we must ensure that we only mark the
12115 * constraint as validated on the parent if it's already validated
12116 * on the children.
12117 *
12118 * We recurse before validating on the parent, to reduce risk of
12119 * deadlocks.
12120 */
12122 {
12124 Relation childrel;
12129 /*
12130 * If we are told not to recurse, there had better not be any
12131 * child tables, because we can't mark the constraint on the
12132 * parent valid unless it is valid for all child tables.
12133 */
12139 /* find_all_inheritors already got lock */
12145 }
12147 /* Queue validation for phase 3 */
12156 Anum_pg_constraint_conbin);
12160 /* Find or create work queue entry for this table */
12164 /*
12165 * Invalidate relcache so that others see the new validated
12166 * constraint.
12167 */
12169 }
12171 /*
12172 * Now update the catalog, while we have the door open.
12173 */
12184 }
12185 else
12193 }
12196 /*
12197 * transformColumnNameList - transform list of column names
12198 *
12199 * Lookup each name and return its attnum and, optionally, type OID
12200 *
12201 * Note: the name of this function suggests that it's general-purpose,
12202 * but actually it's only used to look up names appearing in foreign-key
12203 * clauses. The error messages would need work to use it in other cases,
12204 * and perhaps the validity checks as well.
12205 */
12206 static int
12209 {
12215 {
12217 HeapTuple atttuple;
12218 Form_pg_attribute attform;
12225 attname)));
12235 INDEX_MAX_KEYS)));
12240 attnum++;
12241 }
12244 }
12246 /*
12247 * transformFkeyGetPrimaryKey -
12248 *
12249 * Look up the names, attnums, and types of the primary key attributes
12250 * for the pkrel. Also return the index OID and index opclasses of the
12251 * index supporting the primary key. Also return whether the index has
12252 * WITHOUT OVERLAPS.
12253 *
12254 * All parameters except pkrel are output parameters. Also, the function
12255 * return value is the number of attributes in the primary key.
12256 *
12257 * Used when the column list in the REFERENCES specification is omitted.
12258 */
12259 static int
12264 {
12269 Datum indclassDatum;
12273 /*
12274 * Get the list of index OIDs for the table from the relcache, and look up
12275 * each one in the pg_index syscache until we find one marked primary key
12276 * (hopefully there isn't more than one such). Insist it's valid, too.
12277 */
12283 {
12291 {
12292 /*
12293 * Refuse to use a deferrable primary key. This is per SQL spec,
12294 * and there would be a lot of interesting semantic problems if we
12295 * tried to allow it.
12296 */
12305 }
12307 }
12311 /*
12312 * Check that we found it
12313 */
12320 /* Must get indclass the hard way */
12322 Anum_pg_index_indclass);
12325 /*
12326 * Now build the list of PK attributes from the indkey definition (we
12327 * assume a primary key cannot have expressional elements)
12328 */
12331 {
12339 }
12346 }
12348 /*
12349 * transformFkeyCheckAttrs -
12350 *
12351 * Validate that the 'attnums' columns in the 'pkrel' relation are valid to
12352 * reference as part of a foreign key constraint.
12353 *
12354 * Returns the OID of the unique index supporting the constraint and
12355 * populates the caller-provided 'opclasses' array with the opclasses
12356 * associated with the index columns. Also sets whether the index
12357 * uses WITHOUT OVERLAPS.
12358 *
12359 * Raises an ERROR on validation failure.
12360 */
12361 static Oid
12366 {
12373 j;
12375 /*
12376 * Reject duplicate appearances of columns in the referenced-columns list.
12377 * Such a case is forbidden by the SQL standard, and even if we thought it
12378 * useful to allow it, there would be ambiguity about how to match the
12379 * list to unique indexes (in particular, it'd be unclear which index
12380 * opclass goes with which FK column).
12381 */
12383 {
12385 {
12390 }
12391 }
12393 /*
12394 * Get the list of index OIDs for the table from the relcache, and look up
12395 * each one in the pg_index syscache, and match unique indexes to the list
12396 * of attnums we are given.
12397 */
12401 {
12402 HeapTuple indexTuple;
12403 Form_pg_index indexStruct;
12411 /*
12412 * Must have the right number of columns; must be unique (or if
12413 * temporal then exclusion instead) and not a partial index; forget it
12414 * if there are any expressions, too. Invalid indexes are out as well.
12415 */
12421 {
12422 Datum indclassDatum;
12425 /* Must get indclass the hard way */
12427 Anum_pg_index_indclass);
12430 /*
12431 * The given attnum list may match the index columns in any order.
12432 * Check for a match, and extract the appropriate opclasses while
12433 * we're at it.
12434 *
12435 * We know that attnums[] is duplicate-free per the test at the
12436 * start of this function, and we checked above that the number of
12437 * index columns agrees, so if we find a match for each attnums[]
12438 * entry then we must have a one-to-one match in some order.
12439 */
12441 {
12444 {
12446 {
12450 }
12451 }
12454 }
12455 /* The last attribute in the index must be the PERIOD FK part */
12457 {
12461 }
12463 /*
12464 * Refuse to use a deferrable unique/primary key. This is per SQL
12465 * spec, and there would be a lot of interesting semantic problems
12466 * if we tried to allow it.
12467 */
12469 {
12470 /*
12471 * Remember that we found an otherwise matching index, so that
12472 * we can generate a more appropriate error message.
12473 */
12476 }
12478 /* We need to know whether the index has WITHOUT OVERLAPS */
12481 }
12485 }
12488 {
12494 else
12499 }
12504 }
12506 /*
12507 * findFkeyCast -
12508 *
12509 * Wrapper around find_coercion_pathway() for ATAddForeignKeyConstraint().
12510 * Caller has equal regard for binary coercibility and for an exact match.
12511 */
12512 static CoercionPathType
12514 {
12515 CoercionPathType ret;
12518 {
12521 }
12522 else
12523 {
12527 /* A previously-relied-upon cast is now gone. */
12530 }
12533 }
12535 /*
12536 * Permissions checks on the referenced table for ADD FOREIGN KEY
12537 *
12538 * Note: we have already checked that the user owns the referencing table,
12539 * else we'd have failed much earlier; no additional checks are needed for it.
12540 */
12541 static void
12543 {
12545 AclResult aclresult;
12548 /* Okay if we have relation-level REFERENCES permission */
12550 ACL_REFERENCES);
12553 /* Else we must have REFERENCES on each column */
12555 {
12561 }
12562 }
12564 /*
12565 * Scan the existing rows in a table to verify they meet a proposed FK
12566 * constraint.
12567 *
12568 * Caller must have opened and locked both relations appropriately.
12569 */
12570 static void
12572 Relation rel,
12573 Relation pkrel,
12574 Oid pkindOid,
12575 Oid constraintOid,
12577 {
12579 TableScanDesc scan;
12581 Snapshot snapshot;
12582 MemoryContext oldcxt;
12583 MemoryContext perTupCxt;
12588 /*
12589 * Build a trigger call structure; we'll need it either way.
12590 */
12600 /* we needn't fill in remaining fields */
12602 /*
12603 * See if we can do it with a single LEFT JOIN query. A false result
12604 * indicates we must proceed with the fire-the-trigger method. We can't do
12605 * a LEFT JOIN for temporal FKs yet, but we can once we support temporal
12606 * left joins.
12607 */
12611 /*
12612 * Scan through each tuple, calling RI_FKey_check_ins (insert trigger) as
12613 * if that tuple had just been inserted. If any of those fail, it should
12614 * ereport(ERROR) and that's that.
12615 */
12622 ALLOCSET_SMALL_SIZES);
12626 {
12632 /*
12633 * Make a call to the trigger function
12634 *
12635 * No parameters are passed, but we do set a context
12636 */
12639 /*
12640 * We assume RI_FKey_check_ins won't look at flinfo...
12641 */
12654 }
12661 }
12663 /*
12664 * CreateFKCheckTrigger
12665 * Creates the insert (on_insert=true) or update "check" trigger that
12666 * implements a given foreign key
12667 *
12668 * Returns the OID of the so created trigger.
12669 */
12670 static Oid
12674 {
12675 ObjectAddress trigAddress;
12678 /*
12679 * Note: for a self-referential FK (referencing and referenced tables are
12680 * the same), it is important that the ON UPDATE action fires before the
12681 * CHECK action, since both triggers will fire on the same row during an
12682 * UPDATE event; otherwise the CHECK trigger will be checking a non-final
12683 * state of the row. Triggers fire in name order, so we ensure this by
12684 * using names like "RI_ConstraintTrigger_a_NNNN" for the action triggers
12685 * and "RI_ConstraintTrigger_c_NNNN" for the check triggers.
12686 */
12693 /* Either ON INSERT or ON UPDATE */
12695 {
12698 }
12699 else
12700 {
12703 }
12719 /* Make changes-so-far visible */
12723 }
12725 /*
12726 * createForeignKeyActionTriggers
12727 * Create the referenced-side "action" triggers that implement a foreign
12728 * key.
12729 *
12730 * Returns the OIDs of the so created triggers in *deleteTrigOid and
12731 * *updateTrigOid.
12732 */
12733 static void
12738 {
12740 ObjectAddress trigAddress;
12742 /*
12743 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12744 * DELETE action on the referenced table.
12745 */
12761 {
12791 }
12800 /* Make changes-so-far visible */
12803 /*
12804 * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON
12805 * UPDATE action on the referenced table.
12806 */
12822 {
12852 }
12860 }
12862 /*
12863 * createForeignKeyCheckTriggers
12864 * Create the referencing-side "check" triggers that implement a foreign
12865 * key.
12866 *
12867 * Returns the OIDs of the so created triggers in *insertTrigOid and
12868 * *updateTrigOid.
12869 */
12870 static void
12873 Oid indexOid,
12876 {
12883 }
12885 /*
12886 * ALTER TABLE DROP CONSTRAINT
12887 *
12888 * Like DROP COLUMN, we can't use the normal ALTER TABLE recursion mechanism.
12889 */
12890 static void
12894 {
12895 Relation conrel;
12896 SysScanDesc scan;
12898 HeapTuple tuple;
12903 /*
12904 * Find and drop the target constraint
12905 */
12907 Anum_pg_constraint_conrelid,
12911 Anum_pg_constraint_contypid,
12915 Anum_pg_constraint_conname,
12921 /* There can be at most one matching row */
12923 {
12929 }
12934 {
12940 else
12944 }
12947 }
12949 /*
12950 * Remove a constraint, using its pg_constraint tuple
12951 *
12952 * Implementation for ALTER TABLE DROP CONSTRAINT and ALTER TABLE ALTER COLUMN
12953 * DROP NOT NULL.
12954 *
12955 * Returns the address of the constraint being removed.
12956 */
12957 static ObjectAddress
12960 LOCKMODE lockmode)
12961 {
12962 Relation conrel;
12963 Form_pg_constraint con;
12964 ObjectAddress conobj;
12976 /* Guard against stack overflow due to overly deep inheritance tree. */
12979 /* At top level, permission check was done in ATPrepCmd, else do it */
12988 /*
12989 * If we're asked to drop a constraint which is both defined locally and
12990 * inherited, we can simply mark it as no longer having a local
12991 * definition, and no further changes are required.
12992 *
12993 * XXX We do this for not-null constraints only, not CHECK, because the
12994 * latter have historically not behaved this way and it might be confusing
12995 * to change the behavior now.
12996 */
12999 {
13000 HeapTuple copytup;
13011 }
13013 /* Don't allow drop of inherited constraints */
13020 /*
13021 * See if we have a not-null constraint or a PRIMARY KEY. If so, we have
13022 * more checks and actions below, so obtain the list of columns that are
13023 * constrained by the constraint being dropped.
13024 */
13026 {
13027 AttrNumber colnum;
13033 }
13035 {
13036 Datum adatum;
13059 }
13063 /*
13064 * If it's a foreign-key constraint, we'd better lock the referenced table
13065 * and check that that's not in use, just as we've already done for the
13066 * constrained table (else we might, eg, be dropping a trigger that has
13067 * unfired events). But we can/must skip that in the self-referential
13068 * case.
13069 */
13072 {
13073 Relation frel;
13075 /* Must match lock taken by RemoveTriggerById: */
13079 }
13081 /*
13082 * Perform the actual constraint deletion
13083 */
13087 /*
13088 * If this was a NOT NULL or the primary key, verify that we still have
13089 * constraints to support GENERATED AS IDENTITY or the replica identity.
13090 */
13092 {
13093 Relation attrel;
13097 /* Make implicit attnotnull changes visible */
13102 /*
13103 * We want to test columns for their presence in the primary key, but
13104 * only if we're not dropping it.
13105 */
13108 INDEX_ATTR_BITMAP_PRIMARY_KEY);
13112 {
13113 HeapTuple atttup;
13114 HeapTuple contup;
13115 Form_pg_attribute attForm;
13118 /*
13119 * Obtain pg_attribute tuple and verify conditions on it.
13120 */
13129 /*
13130 * Since the above deletion has been made visible, we can now
13131 * search for any remaining constraints on this column (or these
13132 * columns, in the case we're dropping a multicol primary key.)
13133 * Then, verify whether any further NOT NULL or primary key
13134 * exists: if none and this is a generated identity column or the
13135 * replica identity, abort the whole thing.
13136 */
13140 pkcols))
13143 /*
13144 * It's not valid to drop the not-null constraint for a GENERATED
13145 * AS IDENTITY column.
13146 */
13155 /*
13156 * It's not valid to drop the not-null constraint for a column in
13157 * the replica identity index, either. (FULL is not affected.)
13158 */
13164 }
13166 }
13168 /*
13169 * For partitioned tables, non-CHECK, non-NOT-NULL inherited constraints
13170 * are dropped via the dependency mechanism, so we're done here.
13171 */
13175 {
13178 }
13180 /*
13181 * Propagate to children as appropriate. Unlike most other ALTER
13182 * routines, we have to do this one level of recursion at a time; we can't
13183 * use find_all_inheritors to do it in one pass.
13184 */
13187 else
13190 /*
13191 * For a partitioned table, if partitions exist and we are told not to
13192 * recurse, it's a user error. It doesn't make sense to have a constraint
13193 * be defined only on the parent, especially if it's a partitioned table.
13194 */
13203 {
13204 Relation childrel;
13205 HeapTuple tuple;
13206 Form_pg_constraint childcon;
13211 /* find_inheritance_children already got lock */
13215 /*
13216 * We search for not-null constraints by column name, and others by
13217 * constraint name.
13218 */
13220 {
13225 }
13226 else
13227 {
13228 SysScanDesc scan;
13232 Anum_pg_constraint_conrelid,
13236 Anum_pg_constraint_contypid,
13240 Anum_pg_constraint_conname,
13245 /* There can only be one, so no need to loop */
13251 constrName,
13255 }
13259 /* Right now only CHECK and not-null constraints can be inherited */
13269 {
13270 /*
13271 * If the child constraint has other definition sources, just
13272 * decrement its inheritance count; if not, recurse to delete it.
13273 */
13275 {
13276 /* Time to delete this child constraint, too */
13279 lockmode);
13280 }
13281 else
13282 {
13283 /* Child constraint must survive my deletion */
13287 /* Make update visible */
13289 }
13290 }
13291 else
13292 {
13293 /*
13294 * If we were told to drop ONLY in this table (no recursion) and
13295 * there are no further parents for this constraint, we need to
13296 * mark the inheritors' constraints as locally defined rather than
13297 * inherited.
13298 */
13305 /* Make update visible */
13307 }
13312 }
13314 /*
13315 * In addition, when dropping a primary key from a legacy-inheritance
13316 * parent table, we must recurse to children to mark the corresponding NOT
13317 * NULL constraint as no longer inherited, or drop it if this its last
13318 * reference.
13319 */
13323 {
13327 /*
13328 * Because primary keys are always marked as NO INHERIT, we don't have
13329 * a list of children yet, so obtain one now.
13330 */
13333 /*
13334 * Find out the list of column names to process. Fortunately, we
13335 * already have the list of column numbers.
13336 */
13338 {
13341 }
13344 {
13345 Relation childrel;
13350 /* find_inheritance_children already got lock */
13355 {
13356 HeapTuple contup;
13366 lockmode);
13368 }
13373 }
13374 }
13379 }
13381 /*
13382 * ALTER COLUMN TYPE
13383 *
13384 * Unlike other subcommand types, we do parse transformation for ALTER COLUMN
13385 * TYPE during phase 1 --- the AlterTableCmd passed in here is already
13386 * transformed (and must be, because we rely on some transformed fields).
13387 *
13388 * The point of this is that the execution of all ALTER COLUMN TYPEs for a
13389 * table will be done "in parallel" during phase 3, so all the USING
13390 * expressions should be parsed assuming the original column types. Also,
13391 * this allows a USING expression to refer to a field that will be dropped.
13392 *
13393 * To make this work safely, AT_PASS_DROP then AT_PASS_ALTER_TYPE must be
13394 * the first two execution steps in phase 2; they must not see the effects
13395 * of any other subcommand types, since the USING expressions are parsed
13396 * against the unmodified table's state.
13397 */
13398 static void
13404 {
13409 HeapTuple tuple;
13410 Form_pg_attribute attTup;
13411 AttrNumber attnum;
13412 Oid targettype;
13413 int32 targettypmod;
13414 Oid targetcollid;
13417 AclResult aclresult;
13425 /* lookup the attribute so we can check inheritance status */
13435 /* Can't alter a system attribute */
13440 colName)));
13442 /*
13443 * Don't alter inherited columns. At outer level, there had better not be
13444 * any inherited definition; when recursing, we assume this was checked at
13445 * the parent level (see below).
13446 */
13451 colName)));
13453 /* Don't alter columns used in the partition key */
13459 errmsg("cannot alter column \"%s\" because it is part of the partition key of relation \"%s\"",
13462 /* Look up the target type */
13469 /* And the collation */
13472 /* make sure datatype is legal for a column */
13479 {
13480 /*
13481 * Set up an expression to transform the old data value to the new
13482 * type. If a USING option was given, use the expression as
13483 * transformed by transformAlterTableStmt, else just take the old
13484 * value and try to coerce it. We do this first so that type
13485 * incompatibility can be detected before we waste effort, and because
13486 * we need the expression to be parsed against the original table row
13487 * type.
13488 */
13490 {
13495 }
13500 COERCION_ASSIGNMENT,
13501 COERCE_IMPLICIT_CAST,
13504 {
13505 /* error text depends on whether USING was specified or not */
13513 else
13518 /* translator: USING is SQL, don't translate it */
13522 targettypmod))));
13523 }
13525 /* Fix collations after all else */
13528 /* Plan the expr now so we can accurately assess the need to rewrite. */
13531 /*
13532 * Add a work queue item to make ATRewriteTable update the column
13533 * contents.
13534 */
13543 }
13551 {
13552 /*
13553 * For relations without storage, do this check now. Regular tables
13554 * will check it later when the table is being rewritten.
13555 */
13557 }
13561 /*
13562 * Recurse manually by queueing a new command for each child, if
13563 * necessary. We cannot apply ATSimpleRecursion here because we need to
13564 * remap attribute numbers in the USING expression, if any.
13565 *
13566 * If we are told not to recurse, there had better not be any child
13567 * tables; else the alter would put them out of step.
13568 */
13570 {
13580 /*
13581 * find_all_inheritors does the recursive search of the inheritance
13582 * hierarchy, so all we have to do is process all of the relids in the
13583 * list that it returns.
13584 */
13586 {
13589 Relation childrel;
13590 HeapTuple childtuple;
13591 Form_pg_attribute childattTup;
13596 /* find_all_inheritors already got lock */
13600 /*
13601 * Verify that the child doesn't have any inherited definitions of
13602 * this column that came from outside this inheritance hierarchy.
13603 * (renameatt makes a similar test, though in a different way
13604 * because of its different recursion mechanism.)
13605 */
13607 colName);
13623 /*
13624 * Remap the attribute numbers. If no USING expression was
13625 * specified, there is no need for this step.
13626 */
13628 {
13632 /* create a copy to scribble on */
13641 attmap,
13649 }
13652 }
13653 }
13659 colName)));
13663 }
13665 /*
13666 * When the data type of a column is changed, a rewrite might not be required
13667 * if the new type is sufficiently identical to the old one, and the USING
13668 * clause isn't trying to insert some other value. It's safe to skip the
13669 * rewrite in these cases:
13670 *
13671 * - the old type is binary coercible to the new type
13672 * - the new type is an unconstrained domain over the old type
13673 * - {NEW,OLD} or {OLD,NEW} is {timestamptz,timestamp} and the timezone is UTC
13674 *
13675 * In the case of a constrained domain, we could get by with scanning the
13676 * table and checking the constraint rather than actually rewriting it, but we
13677 * don't currently try to do that.
13678 */
13679 static bool
13681 {
13685 {
13686 /* only one varno, so no need to check that */
13692 {
13698 }
13700 {
13704 {
13709 else
13714 }
13715 }
13716 else
13718 }
13719 }
13721 /*
13722 * ALTER COLUMN .. SET DATA TYPE
13723 *
13724 * Return the address of the modified column.
13725 */
13726 static ObjectAddress
13729 {
13733 HeapTuple heapTup;
13734 Form_pg_attribute attTup,
13735 attOldTup;
13736 AttrNumber attnum;
13737 HeapTuple typeTuple;
13738 Form_pg_type tform;
13739 Oid targettype;
13740 int32 targettypmod;
13741 Oid targetcollid;
13743 Relation attrelation;
13744 Relation depRel;
13746 SysScanDesc scan;
13747 HeapTuple depTup;
13748 ObjectAddress address;
13750 /*
13751 * Clear all the missing values if we're rewriting the table, since this
13752 * renders them pointless.
13753 */
13755 {
13756 Relation newrel;
13761 /* make sure we don't conflict with later attribute modifications */
13763 }
13767 /* Look up the target column */
13778 /* Check for multiple ALTER TYPE on same column --- can't cope */
13784 colName)));
13786 /* Look up the target type (should not fail, since prep found it) */
13790 /* And the collation */
13793 /*
13794 * If there is a default expression for the column, get it and ensure we
13795 * can coerce it to the new datatype. (We must do this before changing
13796 * the column type, because build_column_default itself will try to
13797 * coerce, and will not issue the error message we want if it fails.)
13798 *
13799 * We remove any implicit coercion steps at the top level of the old
13800 * default expression; this has been agreed to satisfy the principle of
13801 * least surprise. (The conversion to the new column type should act like
13802 * it started from what the user sees as the stored expression, and the
13803 * implicit coercions aren't going to be shown.)
13804 */
13806 {
13813 COERCION_ASSIGNMENT,
13814 COERCE_IMPLICIT_CAST,
13817 {
13823 else
13828 }
13829 }
13830 else
13833 /*
13834 * Find everything that depends on the column (constraints, indexes, etc),
13835 * and record enough information to let us recreate the objects.
13836 *
13837 * The actual recreation does not happen here, but only after we have
13838 * performed all the individual ALTER TYPE operations. We have to save
13839 * the info before executing ALTER TYPE, though, else the deparser will
13840 * get confused.
13841 */
13844 /*
13845 * Now scan for dependencies of this column on other things. The only
13846 * things we should find are the dependency on the column datatype and
13847 * possibly a collation dependency. Those can be removed.
13848 */
13852 Anum_pg_depend_classid,
13856 Anum_pg_depend_objid,
13860 Anum_pg_depend_objsubid,
13868 {
13870 ObjectAddress foundObject;
13887 }
13893 /*
13894 * Here we go --- change the recorded column type and collation. (Note
13895 * heapTup is a copy of the syscache entry, so okay to scribble on.) First
13896 * fix up the missing value if any.
13897 */
13899 {
13900 Datum missingval;
13903 /* if rewrite is true the missing value should already be cleared */
13906 /* Get the missing value datum */
13908 Anum_pg_attribute_attmissingval,
13912 /* if it's a null array there is nothing to do */
13915 {
13916 /*
13917 * Get the datum out of the array and repack it in a new array
13918 * built with the new type data. We assume that since the table
13919 * doesn't need rewriting, the actual Datum doesn't need to be
13920 * changed, only the array metadata.
13921 */
13928 HeapTuple newTup;
13940 targettype,
13954 }
13955 }
13977 /* Install dependencies on new datatype and collation */
13981 /*
13982 * Drop any pg_statistic entry for the column, since it's now wrong type
13983 */
13989 /*
13990 * Update the default, if present, by brute force --- remove and re-add
13991 * the default. Probably unsafe to take shortcuts, since the new version
13992 * may well have additional dependencies. (It's okay to do this now,
13993 * rather than after other ALTER TYPE commands, since the default won't
13994 * depend on other column types.)
13995 */
13997 {
13998 /*
13999 * If it's a GENERATED default, drop its dependency records, in
14000 * particular its INTERNAL dependency on the column, which would
14001 * otherwise cause dependency.c to refuse to perform the deletion.
14002 */
14004 {
14011 }
14013 /*
14014 * Make updates-so-far visible, particularly the new pg_attribute row
14015 * which will be updated again.
14016 */
14019 /*
14020 * We use RESTRICT here for safety, but at present we do not expect
14021 * anything to depend on the default.
14022 */
14027 }
14032 /* Cleanup */
14036 }
14038 /*
14039 * Subroutine for ATExecAlterColumnType and ATExecSetExpression: Find everything
14040 * that depends on the column (constraints, indexes, etc), and record enough
14041 * information to let us recreate the objects.
14042 */
14043 static void
14046 {
14047 Relation depRel;
14049 SysScanDesc scan;
14050 HeapTuple depTup;
14057 Anum_pg_depend_refclassid,
14061 Anum_pg_depend_refobjid,
14065 Anum_pg_depend_refobjsubid,
14073 {
14075 ObjectAddress foundObject;
14082 {
14084 {
14089 {
14092 }
14094 {
14095 /*
14096 * This must be a SERIAL column's sequence. We need
14097 * not do anything to it.
14098 */
14100 }
14101 else
14102 {
14103 /* Not expecting any other direct dependencies... */
14106 }
14108 }
14117 /*
14118 * A new-style SQL function can depend on a column, if that
14119 * column is referenced in the parsed function body. Ideally
14120 * we'd automatically update the function by deparsing and
14121 * reparsing it, but that's risky and might well fail anyhow.
14122 * FIXME someday.
14123 *
14124 * This is only a problem for AT_AlterColumnType, not
14125 * AT_SetExpression.
14126 */
14133 colName)));
14138 /*
14139 * View/rule bodies have pretty much the same issues as
14140 * function bodies. FIXME someday.
14141 */
14148 colName)));
14153 /*
14154 * A trigger can depend on a column because the column is
14155 * specified as an update target, or because the column is
14156 * used in the trigger's WHEN condition. The first case would
14157 * not require any extra work, but the second case would
14158 * require updating the WHEN expression, which has the same
14159 * issues as above. Since we can't easily tell which case
14160 * applies, we punt for both. FIXME someday.
14161 */
14168 colName)));
14173 /*
14174 * A policy can depend on a column because the column is
14175 * specified in the policy's USING or WITH CHECK qual
14176 * expressions. It might be possible to rewrite and recheck
14177 * the policy expression, but punt for now. It's certainly
14178 * easy enough to remove and recreate the policy; still, FIXME
14179 * someday.
14180 */
14187 colName)));
14191 {
14196 {
14197 /*
14198 * Ignore the column's own default expression. The
14199 * caller deals with it.
14200 */
14201 }
14202 else
14203 {
14204 /*
14205 * This must be a reference from the expression of a
14206 * generated column elsewhere in the same table.
14207 * Changing the type/generated expression of a column
14208 * that is used by a generated column is not allowed
14209 * by SQL standard, so just punt for now. It might be
14210 * doable with some thinking and effort.
14211 */
14217 colName,
14221 }
14223 }
14227 /*
14228 * Give the extended-stats machinery a chance to fix anything
14229 * that this column type change would break.
14230 */
14236 /*
14237 * Column reference in a PUBLICATION ... FOR TABLE ... WHERE
14238 * clause. Same issues as above. FIXME someday.
14239 */
14246 colName)));
14251 /*
14252 * We don't expect any other sorts of objects to depend on a
14253 * column.
14254 */
14258 }
14259 }
14263 }
14265 /*
14266 * Subroutine for ATExecAlterColumnType: remember that a replica identity
14267 * needs to be reset.
14268 */
14269 static void
14271 {
14279 }
14281 /*
14282 * Subroutine for ATExecAlterColumnType: remember any clustered index.
14283 */
14284 static void
14286 {
14294 }
14296 /*
14297 * Subroutine for ATExecAlterColumnType: remember that a constraint needs
14298 * to be rebuilt (which we might already know).
14299 */
14300 static void
14302 {
14303 /*
14304 * This de-duplication check is critical for two independent reasons: we
14305 * mustn't try to recreate the same constraint twice, and if a constraint
14306 * depends on more than one column whose type is to be altered, we must
14307 * capture its definition string before applying any of the column type
14308 * changes. ruleutils.c will get confused if we ask again later.
14309 */
14311 {
14312 /* OK, capture the constraint's existing definition string */
14314 Oid indoid;
14317 conoid);
14319 defstring);
14321 /*
14322 * For the index of a constraint, if any, remember if it is used for
14323 * the table's replica identity or if it is a clustered index, so that
14324 * ATPostAlterTypeCleanup() can queue up commands necessary to restore
14325 * those properties.
14326 */
14329 {
14332 }
14333 }
14334 }
14336 /*
14337 * Subroutine for ATExecAlterColumnType: remember that an index needs
14338 * to be rebuilt (which we might already know).
14339 */
14340 static void
14342 {
14343 /*
14344 * This de-duplication check is critical for two independent reasons: we
14345 * mustn't try to recreate the same index twice, and if an index depends
14346 * on more than one column whose type is to be altered, we must capture
14347 * its definition string before applying any of the column type changes.
14348 * ruleutils.c will get confused if we ask again later.
14349 */
14351 {
14352 /*
14353 * Before adding it as an index-to-rebuild, we'd better see if it
14354 * belongs to a constraint, and if so rebuild the constraint instead.
14355 * Typically this check fails, because constraint indexes normally
14356 * have only dependencies on their constraint. But it's possible for
14357 * such an index to also have direct dependencies on table columns,
14358 * for example with a partial exclusion constraint.
14359 */
14363 {
14365 }
14366 else
14367 {
14368 /* OK, capture the index's existing definition string */
14372 indoid);
14374 defstring);
14376 /*
14377 * Remember if this index is used for the table's replica identity
14378 * or if it is a clustered index, so that ATPostAlterTypeCleanup()
14379 * can queue up commands necessary to restore those properties.
14380 */
14383 }
14384 }
14385 }
14387 /*
14388 * Subroutine for ATExecAlterColumnType: remember that a statistics object
14389 * needs to be rebuilt (which we might already know).
14390 */
14391 static void
14393 {
14394 /*
14395 * This de-duplication check is critical for two independent reasons: we
14396 * mustn't try to recreate the same statistics object twice, and if the
14397 * statistics object depends on more than one column whose type is to be
14398 * altered, we must capture its definition string before applying any of
14399 * the type changes. ruleutils.c will get confused if we ask again later.
14400 */
14402 {
14403 /* OK, capture the statistics object's existing definition string */
14407 stxoid);
14409 defstring);
14410 }
14411 }
14413 /*
14414 * Cleanup after we've finished all the ALTER TYPE or SET EXPRESSION
14415 * operations for a particular relation. We have to drop and recreate all the
14416 * indexes and constraints that depend on the altered columns. We do the
14417 * actual dropping here, but re-creation is managed by adding work queue
14418 * entries to do those steps later.
14419 */
14420 static void
14422 {
14423 ObjectAddress obj;
14428 /*
14429 * Collect all the constraints and indexes to drop so we can process them
14430 * in a single call. That way we don't have to worry about dependencies
14431 * among them.
14432 */
14435 /*
14436 * Re-parse the index and constraint definitions, and attach them to the
14437 * appropriate work queue entries. We do this before dropping because in
14438 * the case of a FOREIGN KEY constraint, we might not yet have exclusive
14439 * lock on the table the constraint is attached to, and we need to get
14440 * that before reparsing/dropping.
14441 *
14442 * We can't rely on the output of deparsing to tell us which relation to
14443 * operate on, because concurrent activity might have made the name
14444 * resolve differently. Instead, we've got to use the OID of the
14445 * constraint or index we're processing to figure out which relation to
14446 * operate on.
14447 */
14450 {
14452 HeapTuple tup;
14453 Form_pg_constraint con;
14454 Oid relid;
14455 Oid confrelid;
14465 else
14466 {
14467 /* must be a domain constraint */
14471 }
14480 /*
14481 * If the constraint is inherited (only), we don't want to inject a
14482 * new definition here; it'll get recreated when
14483 * ATAddCheckNNConstraint recurses from adding the parent table's
14484 * constraint. But we had to carry the info this far so that we can
14485 * drop the constraint below.
14486 */
14490 /*
14491 * When rebuilding an FK constraint that references the table we're
14492 * modifying, we might not yet have any lock on the FK's table, so get
14493 * one now. We'll need AccessExclusiveLock for the DROP CONSTRAINT
14494 * step, so there's no value in asking for anything weaker.
14495 */
14502 }
14505 {
14507 Oid relid;
14516 }
14518 /* add dependencies for new statistics */
14521 {
14523 Oid relid;
14532 }
14534 /*
14535 * Queue up command to restore replica identity index marking
14536 */
14538 {
14547 /* do it after indexes and constraints */
14550 }
14552 /*
14553 * Queue up command to restore marking of index used for cluster.
14554 */
14556 {
14562 /* do it after indexes and constraints */
14565 }
14567 /*
14568 * It should be okay to use DROP_RESTRICT here, since nothing else should
14569 * be depending on these objects.
14570 */
14575 /*
14576 * The objects will get recreated during subsequent passes over the work
14577 * queue.
14578 */
14579 }
14581 /*
14582 * Parse the previously-saved definition string for a constraint, index or
14583 * statistics object against the newly-established column data type(s), and
14584 * queue up the resulting command parsetrees for execution.
14585 *
14586 * This might fail if, for example, you have a WHERE clause that uses an
14587 * operator that's not available for the new column type.
14588 */
14589 static void
14592 {
14596 Relation rel;
14598 /*
14599 * We expect that we will get only ALTER TABLE and CREATE INDEX
14600 * statements. Hence, there is no need to pass them through
14601 * parse_analyze_*() or the rewriter, but instead we need to pass them
14602 * through parse_utilcmd.c to make them ready for execution.
14603 */
14607 {
14615 cmd));
14617 {
14623 cmd,
14629 }
14634 cmd));
14635 else
14637 }
14639 /* Caller should already have acquired whatever lock we need. */
14642 /*
14643 * Attach each generated command to the proper place in the work queue.
14644 * Note this could result in creation of entirely new work-queue entries.
14645 *
14646 * Also note that we have to tweak the command subtypes, because it turns
14647 * out that re-creation of indexes and constraints has to act a bit
14648 * differently from initial creation.
14649 */
14651 {
14658 {
14665 /* keep the index's comment */
14673 }
14675 {
14680 {
14684 {
14686 Oid indoid;
14693 /* keep any comment on the index */
14702 /* recreate any comment on the constraint */
14704 AT_PASS_OLD_INDEX,
14705 oldId,
14706 rel,
14707 NIL,
14709 }
14711 {
14715 /* rewriting neither side of a FK */
14724 /* recreate any comment on the constraint */
14726 AT_PASS_OLD_CONSTR,
14727 oldId,
14728 rel,
14729 NIL,
14731 }
14733 {
14734 /*
14735 * We see this subtype when a primary key is created
14736 * internally, for example when it is replaced with a new
14737 * constraint (say because one of the columns changes
14738 * type); in this case we need to reinstate attnotnull,
14739 * because it was removed because of the drop of the old
14740 * PK. Schedule this subcommand to an upcoming AT pass.
14741 */
14745 }
14746 else
14749 }
14750 }
14752 {
14756 {
14765 /* recreate any comment on the constraint */
14767 AT_PASS_OLD_CONSTR,
14768 oldId,
14769 NULL,
14772 }
14773 else
14776 }
14778 {
14782 /* keep the statistics object's comment */
14790 }
14791 else
14794 }
14797 }
14799 /*
14800 * Subroutine for ATPostAlterTypeParse() to recreate any existing comment
14801 * for a table or domain constraint that is being rebuilt.
14802 *
14803 * objid is the OID of the constraint.
14804 * Pass "rel" for a table constraint, or "domname" (domain's qualified name
14805 * as a string list) for a domain constraint.
14806 * (We could dig that info, as well as the conname, out of the pg_constraint
14807 * entry; but callers already have them so might as well pass them.)
14808 */
14809 static void
14813 {
14818 /* Look for comment for object wanted, and leave if none */
14823 /* Build CommentStmt node, copying all input data for safety */
14826 {
14832 }
14833 else
14834 {
14839 }
14842 /* Append it to list of commands */
14847 }
14849 /*
14850 * Subroutine for ATPostAlterTypeParse(). Calls out to CheckIndexCompatible()
14851 * for the real analysis, then mutates the IndexStmt based on that verdict.
14852 */
14853 static void
14855 {
14861 {
14864 /* If it's a partitioned index, there is no storage to share. */
14866 {
14870 }
14872 }
14873 }
14875 /*
14876 * Subroutine for ATPostAlterTypeParse().
14877 *
14878 * Stash the old P-F equality operator into the Constraint node, for possible
14879 * use by ATAddForeignKeyConstraint() in determining whether revalidation of
14880 * this constraint can be skipped.
14881 */
14882 static void
14884 {
14885 HeapTuple tup;
14886 Datum adatum;
14900 Anum_pg_constraint_conpfeqop);
14903 /* test follows the one in ri_FetchConstraintInfo() */
14910 /* stash a List of the operator Oids in our Constraint node */
14915 }
14917 /*
14918 * ALTER COLUMN .. OPTIONS ( ... )
14919 *
14920 * Returns the address of the modified column
14921 */
14922 static ObjectAddress
14926 LOCKMODE lockmode)
14927 {
14928 Relation ftrel;
14929 Relation attrel;
14932 HeapTuple tuple;
14933 HeapTuple newtuple;
14938 Datum datum;
14939 Form_pg_foreign_table fttableform;
14940 Form_pg_attribute atttableform;
14941 AttrNumber attnum;
14942 ObjectAddress address;
14947 /* First, determine FDW validator associated to the foreign table. */
14970 /* Prevent them from altering a system attribute */
14979 /* Initialize buffers for new tuple values */
14984 /* Extract the current options */
14986 tuple,
14987 Anum_pg_attribute_attfdwoptions,
14992 /* Transform the options */
14994 datum,
14995 options,
15000 else
15005 /* Everything looks good - update the tuple */
15025 }
15027 /*
15028 * ALTER TABLE OWNER
15029 *
15030 * recursing is true if we are recursing from a table to its indexes,
15031 * sequences, or toast table. We don't allow the ownership of those things to
15032 * be changed separately from the parent table. Also, we can skip permission
15033 * checks (this is necessary not just an optimization, else we'd fail to
15034 * handle toast tables properly).
15035 *
15036 * recursing is also true if ALTER TYPE OWNER is calling us to fix up a
15037 * free-standing composite type.
15038 */
15039 void
15041 {
15042 Relation target_rel;
15043 Relation class_rel;
15044 HeapTuple tuple;
15045 Form_pg_class tuple_class;
15047 /*
15048 * Get exclusive lock till end of transaction on the target table. Use
15049 * relation_open so that we can work on indexes and sequences.
15050 */
15053 /* Get its pg_class tuple, too */
15061 /* Can we change the ownership of this tuple? */
15063 {
15069 /* ok to change owner */
15073 {
15074 /*
15075 * Because ALTER INDEX OWNER used to be allowed, and in fact
15076 * is generated by old versions of pg_dump, we give a warning
15077 * and do nothing rather than erroring out. Also, to avoid
15078 * unnecessary chatter while restoring those old dumps, say
15079 * nothing at all if the command would be a no-op anyway.
15080 */
15087 /* quick hack to exit via the no-op path */
15089 }
15103 {
15104 /* if it's an owned sequence, disallow changing it by itself */
15105 Oid tableId;
15106 int32 colId;
15117 }
15126 /* translator: %s is an SQL ALTER command */
15133 /* FALL THRU */
15140 }
15142 /*
15143 * If the new owner is the same as the existing owner, consider the
15144 * command to have succeeded. This is for dump restoration purposes.
15145 */
15147 {
15152 Datum aclDatum;
15154 HeapTuple newtuple;
15156 /* skip permission checks when recursing to index or toast table */
15158 {
15159 /* Superusers can always do it */
15161 {
15163 AclResult aclresult;
15165 /* Otherwise, must be owner of the existing object */
15170 /* Must be able to become new owner */
15173 /* New owner must have CREATE privilege on namespace */
15175 ACL_CREATE);
15179 }
15180 }
15188 /*
15189 * Determine the modified ACL for the new owner. This is only
15190 * necessary when the ACL is non-null.
15191 */
15193 Anum_pg_class_relacl,
15196 {
15201 }
15203 newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
15209 /*
15210 * We must similarly update any per-column ACLs to reflect the new
15211 * owner; for neatness reasons that's split out as a subroutine.
15212 */
15215 newOwnerId);
15217 /*
15218 * Update owner dependency reference, if any. A composite type has
15219 * none, because it's tracked for the pg_type entry instead of here;
15220 * indexes and TOAST tables don't have their own entries either.
15221 */
15227 newOwnerId);
15229 /*
15230 * Also change the ownership of the table's row type, if it has one
15231 */
15235 /*
15236 * If we are operating on a table or materialized view, also change
15237 * the ownership of any indexes and sequences that belong to the
15238 * relation, as well as its toast table (if it has one).
15239 */
15244 {
15248 /* Find all the indexes belonging to this relation */
15251 /* For each index, recursively change its ownership */
15256 }
15258 /* If it has a toast table, recurse to change its ownership */
15263 /* If it has dependent sequences, recurse to change them too */
15265 }
15272 }
15274 /*
15275 * change_owner_fix_column_acls
15276 *
15277 * Helper function for ATExecChangeOwner. Scan the columns of the table
15278 * and fix any non-null column ACLs to reflect the new owner.
15279 */
15280 static void
15282 {
15283 Relation attRelation;
15284 SysScanDesc scan;
15286 HeapTuple attributeTuple;
15290 Anum_pg_attribute_attrelid,
15296 {
15302 Datum aclDatum;
15304 HeapTuple newtuple;
15306 /* Ignore dropped columns */
15311 Anum_pg_attribute_attacl,
15314 /* Null ACLs do not require changes */
15333 }
15336 }
15338 /*
15339 * change_owner_recurse_to_sequences
15340 *
15341 * Helper function for ATExecChangeOwner. Examines pg_depend searching
15342 * for sequences that are dependent on serial columns, and changes their
15343 * ownership.
15344 */
15345 static void
15347 {
15348 Relation depRel;
15349 SysScanDesc scan;
15351 HeapTuple tup;
15353 /*
15354 * SERIAL sequences are those having an auto dependency on one of the
15355 * table's columns (we don't care *which* column, exactly).
15356 */
15360 Anum_pg_depend_refclassid,
15364 Anum_pg_depend_refobjid,
15367 /* we leave refobjsubid unspecified */
15373 {
15375 Relation seqRel;
15377 /* skip dependencies other than auto dependencies on columns */
15384 /* Use relation_open just in case it's an index */
15387 /* skip non-sequence relations */
15389 {
15390 /* No need to keep the lock */
15393 }
15395 /* We don't need to close the sequence while we alter it. */
15398 /* Now we can close it. Keep the lock till end of transaction. */
15400 }
15405 }
15407 /*
15408 * ALTER TABLE CLUSTER ON
15409 *
15410 * The only thing we have to do is to change the indisclustered bits.
15411 *
15412 * Return the address of the new clustering index.
15413 */
15414 static ObjectAddress
15416 {
15417 Oid indexOid;
15418 ObjectAddress address;
15428 /* Check index is valid to cluster on */
15431 /* And do the work */
15438 }
15440 /*
15441 * ALTER TABLE SET WITHOUT CLUSTER
15442 *
15443 * We have to find any indexes on the table that have indisclustered bit
15444 * set and turn it off.
15445 */
15446 static void
15448 {
15450 }
15452 /*
15453 * Preparation phase for SET ACCESS METHOD
15454 *
15455 * Check that the access method exists and determine whether a change is
15456 * actually needed.
15457 */
15458 static void
15460 {
15461 Oid amoid;
15463 /*
15464 * Look up the access method name and check that it differs from the
15465 * table's current AM. If DEFAULT was specified for a partitioned table
15466 * (amname is NULL), set it to InvalidOid to reset the catalogued AM.
15467 */
15472 else
15475 /* if it's a match, phase 3 doesn't need to do anything */
15479 /* Save info for Phase 3 to do the real work */
15483 }
15485 /*
15486 * Special handling of ALTER TABLE SET ACCESS METHOD for relations with no
15487 * storage that have an interest in preserving AM.
15488 *
15489 * Since these have no storage, setting the access method is a catalog only
15490 * operation.
15491 */
15492 static void
15494 {
15495 Relation pg_class;
15496 Oid oldAccessMethodId;
15497 HeapTuple tuple;
15498 Form_pg_class rd_rel;
15501 /*
15502 * Shouldn't be called on relations having storage; these are processed in
15503 * phase 3.
15504 */
15507 /* Get a modifiable copy of the relation's pg_class row. */
15515 /* Update the pg_class row. */
15519 /* Leave if no update required */
15521 {
15525 }
15529 /*
15530 * Update the dependency on the new access method. No dependency is added
15531 * if the new access method is InvalidOid (default case). Be very careful
15532 * that this has to compare the previous value stored in pg_class with the
15533 * new one.
15534 */
15536 {
15537 ObjectAddress relobj,
15538 referenced;
15540 /*
15541 * New access method is defined and there was no dependency
15542 * previously, so record a new one.
15543 */
15547 }
15550 {
15551 /*
15552 * There was an access method defined, and no new one, so just remove
15553 * the existing dependency.
15554 */
15556 AccessMethodRelationId,
15557 DEPENDENCY_NORMAL);
15558 }
15559 else
15560 {
15564 /* Both are valid, so update the dependency */
15566 AccessMethodRelationId,
15568 }
15570 /* make the relam and dependency changes visible */
15577 }
15579 /*
15580 * ALTER TABLE SET TABLESPACE
15581 */
15582 static void
15583 ATPrepSetTableSpace(AlteredTableInfo *tab, Relation rel, const char *tablespacename, LOCKMODE lockmode)
15584 {
15585 Oid tablespaceId;
15587 /* Check that the tablespace exists */
15590 /* Check permissions except when moving to database's default */
15592 {
15593 AclResult aclresult;
15598 }
15600 /* Save info for Phase 3 to do the real work */
15607 }
15609 /*
15610 * Set, reset, or replace reloptions.
15611 */
15612 static void
15614 LOCKMODE lockmode)
15615 {
15616 Oid relid;
15617 Relation pgclass;
15618 HeapTuple tuple;
15619 HeapTuple newtuple;
15620 Datum datum;
15622 Datum newOptions;
15633 /* Fetch heap tuple */
15640 {
15641 /*
15642 * If we're supposed to replace the reloptions list, we just pretend
15643 * there were none before.
15644 */
15647 }
15648 else
15649 {
15650 /* Get the old reloptions */
15653 }
15655 /* Generate new proposed reloptions (text array) */
15660 /* Validate */
15662 {
15685 }
15687 /* Special-case validation of view options */
15689 {
15696 {
15701 }
15703 /*
15704 * If the check option is specified, look to see if the view is
15705 * actually auto-updatable or not.
15706 */
15708 {
15717 }
15718 }
15720 /*
15721 * All we need do here is update the pg_class row; the new options will be
15722 * propagated into relcaches during post-commit cache inval.
15723 */
15730 else
15746 /* repeat the whole exercise for the toast table, if there's one */
15748 {
15749 Relation toastrel;
15754 /* Fetch heap tuple */
15760 {
15761 /*
15762 * If we're supposed to replace the reloptions list, we just
15763 * pretend there were none before.
15764 */
15767 }
15768 else
15769 {
15770 /* Get the old reloptions */
15773 }
15787 else
15806 }
15809 }
15811 /*
15812 * Execute ALTER TABLE SET TABLESPACE for cases where there is no tuple
15813 * rewriting to be done, so we just want to copy the data as fast as possible.
15814 */
15815 static void
15817 {
15818 Relation rel;
15819 Oid reltoastrelid;
15820 RelFileNumber newrelfilenumber;
15821 RelFileLocator newrlocator;
15825 /*
15826 * Need lock here in case we are recursing to toast table or index
15827 */
15830 /* Check first if relation can be moved to new tablespace */
15832 {
15837 }
15840 /* Fetch the list of indexes on toast relation if necessary */
15842 {
15847 }
15849 /*
15850 * Relfilenumbers are not unique in databases across tablespaces, so we
15851 * need to allocate a new one in the new tablespace.
15852 */
15856 /* Open old and new relation */
15861 /* hand off to AM to actually create new rel storage and copy the data */
15863 {
15865 }
15866 else
15867 {
15870 }
15872 /*
15873 * Update the pg_class row.
15874 *
15875 * NB: This wouldn't work if ATExecSetTableSpace() were allowed to be
15876 * executed on pg_class or its indexes (the above copy wouldn't contain
15877 * the updated pg_class entry), but that's forbidden with
15878 * CheckRelationTableSpaceMove().
15879 */
15888 /* Make sure the reltablespace change is visible */
15891 /* Move associated toast relation and/or indexes, too */
15897 /* Clean up */
15899 }
15901 /*
15902 * Special handling of ALTER TABLE SET TABLESPACE for relations with no
15903 * storage that have an interest in preserving tablespace.
15904 *
15905 * Since these have no storage the tablespace can be updated with a simple
15906 * metadata only operation to update the tablespace.
15907 */
15908 static void
15910 {
15911 /*
15912 * Shouldn't be called on relations having storage; these are processed in
15913 * phase 3.
15914 */
15917 /* check if relation can be moved to its new tablespace */
15919 {
15924 }
15926 /* Update can be done, so change reltablespace */
15931 /* Make sure the reltablespace change is visible */
15933 }
15935 /*
15936 * Alter Table ALL ... SET TABLESPACE
15937 *
15938 * Allows a user to move all objects of some type in a given tablespace in the
15939 * current database to another tablespace. Objects can be chosen based on the
15940 * owner of the object also, to allow users to move only their objects.
15941 * The user must have CREATE rights on the new tablespace, as usual. The main
15942 * permissions handling is done by the lower-level table move function.
15943 *
15944 * All to-be-moved objects are locked first. If NOWAIT is specified and the
15945 * lock can't be acquired then we ereport(ERROR).
15946 */
15947 Oid
15949 {
15953 Relation rel;
15954 TableScanDesc scan;
15955 HeapTuple tuple;
15956 Oid orig_tablespaceoid;
15957 Oid new_tablespaceoid;
15960 /* Ensure we were not asked to move something we can't */
15967 /* Get the orig and new tablespace OIDs */
15971 /* Can't move shared relations in to or out of pg_global */
15972 /* This is also checked by ATExecSetTableSpace, but nice to stop earlier */
15979 /*
15980 * Must have CREATE rights on the new tablespace, unless it is the
15981 * database default tablespace (which all users implicitly have CREATE
15982 * rights on).
15983 */
15985 {
15986 AclResult aclresult;
15989 ACL_CREATE);
15993 }
15995 /*
15996 * Now that the checks are done, check if we should set either to
15997 * InvalidOid because it is our database's default tablespace.
15998 */
16005 /* no-op */
16009 /*
16010 * Walk the list of objects in the tablespace and move them. This will
16011 * only find objects in our database, of course.
16012 */
16014 Anum_pg_class_reltablespace,
16021 {
16025 /*
16026 * Do not move objects in pg_catalog as part of this, if an admin
16027 * really wishes to do so, they can issue the individual ALTER
16028 * commands directly.
16029 *
16030 * Also, explicitly avoid any shared tables, temp tables, or TOAST
16031 * (TOAST will be moved with the main table).
16032 */
16039 /* Only move the object type requested */
16050 /* Check if we are only moving objects owned by certain roles */
16054 /*
16055 * Handle permissions-checking here since we are locking the tables
16056 * and also to avoid doing a bunch of work only to fail part-way. Note
16057 * that permissions will also be checked by AlterTableInternal().
16058 *
16059 * Caller must be considered an owner on the table to move it.
16060 */
16072 else
16075 /* Add to our list of objects to move */
16077 }
16089 /* Everything is locked, loop through and move all of the relations. */
16091 {
16101 /* OID is set by AlterTableInternal */
16104 }
16107 }
16109 static void
16111 {
16112 SMgrRelation dstrel;
16114 /*
16115 * Since we copy the file directly without looking at the shared buffers,
16116 * we'd better first flush out any pages of the source relation that are
16117 * in shared buffers. We assume no new changes will be made while we are
16118 * holding exclusive lock on the rel.
16119 */
16122 /*
16123 * Create and copy all forks of the relation, and schedule unlinking of
16124 * old physical files.
16125 *
16126 * NOTE: any conflict in relfilenumber value will be caught in
16127 * RelationCreateStorage().
16128 */
16131 /* copy main fork */
16135 /* copy those extra forks that exist */
16138 {
16140 {
16143 /*
16144 * WAL log creation if the relation is persistent, or this is the
16145 * init fork of an unlogged relation.
16146 */
16153 }
16154 }
16156 /* drop old relation, and close new one */
16159 }
16161 /*
16162 * ALTER TABLE ENABLE/DISABLE TRIGGER
16163 *
16164 * We just pass this off to trigger.c.
16165 */
16166 static void
16169 LOCKMODE lockmode)
16170 {
16173 lockmode);
16177 }
16179 /*
16180 * ALTER TABLE ENABLE/DISABLE RULE
16181 *
16182 * We just pass this off to rewriteDefine.c.
16183 */
16184 static void
16187 {
16192 }
16194 /*
16195 * ALTER TABLE INHERIT
16196 *
16197 * Add a parent to the child's parents. This verifies that all the columns and
16198 * check constraints of the parent appear in the child and that they have the
16199 * same data types and expressions.
16200 */
16201 static void
16203 {
16218 }
16220 /*
16221 * Return the address of the new parent relation.
16222 */
16223 static ObjectAddress
16225 {
16226 Relation parent_rel;
16228 ObjectAddress address;
16231 /*
16232 * A self-exclusive lock is needed here. See the similar case in
16233 * MergeAttributes() for a full explanation.
16234 */
16237 /*
16238 * Must be owner of both parent and child -- child was checked by
16239 * ATSimplePermissions call in ATPrepCmd
16240 */
16243 /* Permanent rels cannot inherit from temporary ones */
16251 /* If parent rel is temp, it must belong to this session */
16258 /* Ditto for the child */
16265 /* Prevent partitioned tables from becoming inheritance parents */
16272 /* Likewise for partitions */
16278 /*
16279 * Prevent circularity by seeing if proposed parent inherits from child.
16280 * (In particular, this disallows making a rel inherit from itself.)
16281 *
16282 * This is not completely bulletproof because of race conditions: in
16283 * multi-level inheritance trees, someone else could concurrently be
16284 * making another inheritance link that closes the loop but does not join
16285 * either of the rels we have locked. Preventing that seems to require
16286 * exclusive locks on the entire inheritance tree, which is a cure worse
16287 * than the disease. find_all_inheritors() will cope with circularity
16288 * anyway, so don't sweat it too much.
16289 *
16290 * We use weakest lock we can on child's children, namely AccessShareLock.
16291 */
16303 /*
16304 * If child_rel has row-level triggers with transition tables, we
16305 * currently don't allow it to become an inheritance child. See also
16306 * prohibitions in ATExecAttachPartition() and CreateTrigger().
16307 */
16314 errdetail("ROW triggers with transition tables are not supported in inheritance hierarchies.")));
16316 /* OK to create inheritance */
16319 /*
16320 * If parent_rel has a primary key, then child_rel has not-null
16321 * constraints that make these columns as non nullable. Make those
16322 * constraints as inherited.
16323 */
16329 /* keep our lock on the parent relation until commit */
16333 }
16335 /*
16336 * CreateInheritance
16337 * Catalog manipulation portion of creating inheritance between a child
16338 * table and a parent table.
16339 *
16340 * Common to ATExecAddInherit() and ATExecAttachPartition().
16341 */
16342 static void
16344 {
16345 Relation catalogRelation;
16346 SysScanDesc scan;
16347 ScanKeyData key;
16348 HeapTuple inheritsTuple;
16349 int32 inhseqno;
16351 /* Note: get RowExclusiveLock because we will write pg_inherits below. */
16354 /*
16355 * Check for duplicates in the list of parents, and determine the highest
16356 * inhseqno already present; we'll use the next one for the new parent.
16357 * Also, if proposed child is a partition, it cannot already be
16358 * inheriting.
16359 *
16360 * Note: we do not reject the case where the child already inherits from
16361 * the parent indirectly; CREATE TABLE doesn't reject comparable cases.
16362 */
16364 Anum_pg_inherits_inhrelid,
16370 /* inhseqno sequences start at 1 */
16373 {
16384 }
16387 /* Match up the columns and bump attinhcount as needed */
16390 /* Match up the constraints and bump coninhcount as needed */
16393 /*
16394 * OK, it looks valid. Make the catalog entries that show inheritance.
16395 */
16399 catalogRelation,
16401 RELKIND_PARTITIONED_TABLE);
16403 /* Now we're done with pg_inherits */
16405 }
16407 /*
16408 * Obtain the source-text form of the constraint expression for a check
16409 * constraint, given its pg_constraint tuple
16410 */
16413 {
16414 Form_pg_constraint con;
16416 Datum attr;
16417 Datum expr;
16427 }
16429 /*
16430 * Determine whether two check constraints are functionally equivalent
16431 *
16432 * The test we apply is to see whether they reverse-compile to the same
16433 * source string. This insulates us from issues like whether attributes
16434 * have the same physical column numbers in parent and child relations.
16435 */
16436 static bool
16438 {
16447 else
16449 }
16451 /*
16452 * Check columns in child table match up with columns in parent, and increment
16453 * their attinhcount.
16454 *
16455 * Called by CreateInheritance
16456 *
16457 * Currently all parent columns must be found in child. Missing columns are an
16458 * error. One day we might consider creating new columns like CREATE TABLE
16459 * does. However, that is widely unpopular --- in the common use case of
16460 * partitioned tables it's a foot-gun.
16461 *
16462 * The data type must match exactly. If the parent column is NOT NULL then
16463 * the child must be as well. Defaults are not compared, however.
16464 */
16465 static void
16467 {
16468 Relation attrrel;
16469 TupleDesc parent_desc;
16475 {
16478 HeapTuple tuple;
16480 /* Ignore dropped columns in the parent. */
16484 /* Find same column in child (matching on column name). */
16487 {
16503 /*
16504 * If the parent has a not-null constraint that's not NO INHERIT,
16505 * make sure the child has one too.
16506 *
16507 * Other constraints are checked elsewhere.
16508 */
16510 {
16511 HeapTuple contup;
16520 parent_attname));
16521 }
16523 /*
16524 * Child column must be generated if and only if parent column is.
16525 */
16535 /*
16536 * Regular inheritance children are independent enough not to
16537 * inherit identity columns. But partitions are integral part of
16538 * a partitioned table and inherit identity column.
16539 */
16543 /*
16544 * OK, bump the child column's inheritance count. (If we fail
16545 * later on, this change will just roll back.)
16546 */
16553 /*
16554 * In case of partitions, we must enforce that value of attislocal
16555 * is same in all partitions. (Note: there are only inherited
16556 * attributes in partitions)
16557 */
16559 {
16562 }
16566 }
16567 else
16568 {
16572 }
16573 }
16576 }
16578 /*
16579 * Check constraints in child table match up with constraints in parent,
16580 * and increment their coninhcount.
16581 *
16582 * Constraints that are marked ONLY in the parent are ignored.
16583 *
16584 * Called by CreateInheritance
16585 *
16586 * Currently all constraints in parent must be present in the child. One day we
16587 * may consider adding new constraints like CREATE TABLE does.
16588 *
16589 * XXX This is O(N^2) which may be an issue with tables with hundreds of
16590 * constraints. As long as tables have more like 10 constraints it shouldn't be
16591 * a problem though. Even 100 constraints ought not be the end of the world.
16592 *
16593 * XXX See MergeWithExistingConstraint too if you change this code.
16594 */
16595 static void
16597 {
16598 Relation constraintrel;
16599 SysScanDesc parent_scan;
16600 ScanKeyData parent_key;
16601 HeapTuple parent_tuple;
16606 /* Outer loop scans through the parent's constraint definitions */
16608 Anum_pg_constraint_conrelid,
16615 {
16617 SysScanDesc child_scan;
16618 ScanKeyData child_key;
16619 HeapTuple child_tuple;
16626 /* if the parent's constraint is marked NO INHERIT, it's not inherited */
16630 /* Search for a child constraint matching this one */
16632 Anum_pg_constraint_conrelid,
16639 {
16641 HeapTuple child_copy;
16646 /*
16647 * CHECK constraint are matched by name, NOT NULL ones by
16648 * attribute number
16649 */
16651 {
16655 }
16657 {
16665 }
16674 /*
16675 * If the CHECK child constraint is "no inherit" then cannot
16676 * merge.
16677 *
16678 * This is not desirable for not-null constraints, mostly because
16679 * it breaks our pg_upgrade strategy, but it also makes sense on
16680 * its own: if a child has its own not-null constraint and then
16681 * acquires a parent with the same constraint, then we start to
16682 * enforce that constraint for all the descendants of that child
16683 * too, if any.
16684 */
16692 /*
16693 * If the child constraint is "not valid" then cannot merge with a
16694 * valid parent constraint
16695 */
16702 /*
16703 * OK, bump the child constraint's inheritance count. (If we fail
16704 * later on, this change will just roll back.)
16705 */
16715 {
16716 /*
16717 * If the child has children, it's not possible to turn a NO
16718 * INHERIT constraint into an inheritable one: we would need
16719 * to recurse to create constraints in those children, but
16720 * this is not a good place to do that.
16721 */
16724 errmsg("cannot add NOT NULL constraint to column \"%s\" of relation \"%s\" with inheritance children",
16733 }
16735 /*
16736 * In case of partitions, an inherited constraint must be
16737 * inherited only once since it cannot have multiple parents and
16738 * it is never considered local.
16739 */
16741 {
16744 }
16751 }
16756 {
16769 }
16770 }
16774 }
16776 /*
16777 * ALTER TABLE NO INHERIT
16778 *
16779 * Return value is the address of the relation that is no longer parent.
16780 */
16781 static ObjectAddress
16783 {
16784 ObjectAddress address;
16785 Relation parent_rel;
16792 /*
16793 * AccessShareLock on the parent is probably enough, seeing that DROP
16794 * TABLE doesn't lock parent tables at all. We need some lock since we'll
16795 * be inspecting the parent's schema.
16796 */
16799 /*
16800 * We don't bother to check ownership of the parent table --- ownership of
16801 * the child is presumed enough rights.
16802 */
16804 /* Off to RemoveInheritance() where most of the work happens */
16807 /*
16808 * If parent_rel has a primary key, then child_rel has not-null
16809 * constraints that make these columns as non nullable. Mark those
16810 * constraints as no longer inherited by this parent.
16811 */
16814 /*
16815 * If the parent has a primary key, then we decrement counts for all NOT
16816 * NULL constraints
16817 */
16822 /* keep our lock on the parent relation until commit */
16826 }
16828 /*
16829 * MarkInheritDetached
16830 *
16831 * Set inhdetachpending for a partition, for ATExecDetachPartition
16832 * in concurrent mode. While at it, verify that no other partition is
16833 * already pending detach.
16834 */
16835 static void
16837 {
16838 Relation catalogRelation;
16839 SysScanDesc scan;
16840 ScanKeyData key;
16841 HeapTuple inheritsTuple;
16846 /*
16847 * Find pg_inherits entries by inhparent. (We need to scan them all in
16848 * order to verify that no other partition is pending detach.)
16849 */
16852 Anum_pg_inherits_inhparent,
16859 {
16860 Form_pg_inherits inhForm;
16870 errhint("Use ALTER TABLE ... DETACH PARTITION ... FINALIZE to complete the pending detach operation."));
16873 {
16874 HeapTuple newtup;
16881 newtup);
16884 /* keep looking, to ensure we catch others pending detach */
16885 }
16886 }
16888 /* Done */
16898 }
16900 /*
16901 * RemoveInheritance
16902 *
16903 * Drop a parent from the child's parents. This just adjusts the attinhcount
16904 * and attislocal of the columns and removes the pg_inherit and pg_depend
16905 * entries. expect_detached is passed down to DeleteInheritsTuple, q.v..
16906 *
16907 * If attinhcount goes to 0 then attislocal gets set to true. If it goes back
16908 * up attislocal stays true, which means if a child is ever removed from a
16909 * parent then its columns will never be automatically dropped which may
16910 * surprise. But at least we'll never surprise by dropping columns someone
16911 * isn't expecting to be dropped which would actually mean data loss.
16912 *
16913 * coninhcount and conislocal for inherited constraints are adjusted in
16914 * exactly the same way.
16915 *
16916 * Common to ATExecDropInherit() and ATExecDetachPartition().
16917 */
16918 static void
16920 {
16921 Relation catalogRelation;
16922 SysScanDesc scan;
16924 HeapTuple attributeTuple,
16925 constraintTuple;
16935 expect_detached,
16938 {
16945 else
16951 }
16953 /*
16954 * Search through child columns looking for ones matching parent rel
16955 */
16958 Anum_pg_attribute_attrelid,
16964 {
16967 /* Ignore if dropped or not inherited */
16975 {
16976 /* Decrement inhcount and possibly set islocal to true */
16986 }
16987 }
16991 /*
16992 * Likewise, find inherited check constraints and disinherit them. To do
16993 * this, we first need a list of the names of the parent's check
16994 * constraints. (We cheat a bit by only checking for name matches,
16995 * assuming that the expressions will match.)
16996 *
16997 * For NOT NULL columns, we store column numbers to match.
16998 */
17001 Anum_pg_constraint_conrelid,
17011 {
17018 }
17022 /* Now scan the child's constraints */
17024 Anum_pg_constraint_conrelid,
17031 {
17036 /*
17037 * Match CHECK constraints by name, not-null constraints by column
17038 * number, and ignore all others.
17039 */
17041 {
17043 {
17046 {
17049 }
17050 }
17051 }
17053 {
17057 {
17059 {
17062 }
17063 }
17064 }
17065 else
17069 {
17070 /* Decrement inhcount and possibly set islocal to true */
17084 }
17085 }
17091 RelationRelationId,
17095 /*
17096 * Post alter hook of this inherits. Since object_access_hook doesn't take
17097 * multiple object identifiers, we relay oid of parent relation using
17098 * auxiliary_id argument.
17099 */
17103 }
17105 /*
17106 * Adjust coninhcount of not-null constraints upwards or downwards when a
17107 * table is marked as inheriting or no longer doing so a table with a primary
17108 * key.
17109 *
17110 * Note: these constraints are not dropped, even if their inhcount goes to zero
17111 * and conislocal is false. Instead we mark the constraints as locally defined.
17112 * This is seen as more useful behavior, with no downsides. The user can always
17113 * drop them afterwards.
17114 */
17115 static void
17117 {
17120 /* Quick exit when parent has no PK */
17125 INDEX_ATTR_BITMAP_PRIMARY_KEY);
17127 {
17137 {
17140 }
17142 /*
17143 * CCI is needed in case there's a NOT NULL PRIMARY KEY column in the
17144 * parent: the relevant not-null constraint in the child already had
17145 * its inhcount modified earlier.
17146 */
17149 inhcount);
17150 }
17151 }
17153 /*
17154 * Drop the dependency created by StoreCatalogInheritance1 (CREATE TABLE
17155 * INHERITS/ALTER TABLE INHERIT -- refclassid will be RelationRelationId) or
17156 * heap_create_with_catalog (CREATE TABLE OF/ALTER TABLE OF -- refclassid will
17157 * be TypeRelationId). There's no convenient way to do this, so go trawling
17158 * through pg_depend.
17159 */
17160 static void
17162 DependencyType deptype)
17163 {
17164 Relation catalogRelation;
17165 SysScanDesc scan;
17167 HeapTuple depTuple;
17172 Anum_pg_depend_classid,
17176 Anum_pg_depend_objid,
17180 Anum_pg_depend_objsubid,
17188 {
17196 }
17200 }
17202 /*
17203 * ALTER TABLE OF
17204 *
17205 * Attach a table to a composite type, as though it had been created with CREATE
17206 * TABLE OF. All attname, atttypid, atttypmod and attcollation must match. The
17207 * subject table must not have inheritance parents. These restrictions ensure
17208 * that you cannot create a configuration impossible with CREATE TABLE OF alone.
17209 *
17210 * The address of the type is returned.
17211 */
17212 static ObjectAddress
17214 {
17216 Type typetuple;
17217 Form_pg_type typeform;
17219 Relation inheritsRelation,
17220 relationRelation;
17221 SysScanDesc scan;
17222 ScanKeyData key;
17223 AttrNumber table_attno,
17224 type_attno;
17225 TupleDesc typeTupleDesc,
17226 tableTupleDesc;
17227 ObjectAddress tableobj,
17228 typeobj;
17229 HeapTuple classtuple;
17231 /* Validate the type. */
17237 /* Fail if the table has any inheritance parents. */
17240 Anum_pg_inherits_inhrelid,
17252 /*
17253 * Check the tuple descriptors for compatibility. Unlike inheritance, we
17254 * require that the order also match. However, attnotnull need not match.
17255 */
17260 {
17261 Form_pg_attribute type_attr,
17262 table_attr;
17266 /* Get the next non-dropped type attribute. */
17272 /* Get the next non-dropped table attribute. */
17273 do
17274 {
17279 type_attname)));
17281 table_attno++;
17285 /* Compare name. */
17292 /* Compare type. */
17300 }
17303 /* Any remaining columns at the end of the table had better be dropped. */
17305 {
17314 }
17316 /* If the table was already typed, drop the existing dependency. */
17319 DEPENDENCY_NORMAL);
17321 /* Record a dependency on the new type. */
17330 /* Update pg_class.reloftype */
17346 }
17348 /*
17349 * ALTER TABLE NOT OF
17350 *
17351 * Detach a typed table from its originating type. Just clear reloftype and
17352 * remove the dependency.
17353 */
17354 static void
17356 {
17358 Relation relationRelation;
17359 HeapTuple tuple;
17367 /*
17368 * We don't bother to check ownership of the type --- ownership of the
17369 * table is presumed enough rights. No lock required on the type, either.
17370 */
17373 DEPENDENCY_NORMAL);
17375 /* Clear pg_class.reloftype */
17387 }
17389 /*
17390 * relation_mark_replica_identity: Update a table's replica identity
17391 *
17392 * Iff ri_type = REPLICA_IDENTITY_INDEX, indexOid must be the Oid of a suitable
17393 * index. Otherwise, it must be InvalidOid.
17394 *
17395 * Caller had better hold an exclusive lock on the relation, as the results
17396 * of running two of these concurrently wouldn't be pretty.
17397 */
17398 static void
17401 {
17402 Relation pg_index;
17403 Relation pg_class;
17404 HeapTuple pg_class_tuple;
17405 HeapTuple pg_index_tuple;
17406 Form_pg_class pg_class_form;
17407 Form_pg_index pg_index_form;
17410 /*
17411 * Check whether relreplident has changed, and update it if so.
17412 */
17421 {
17424 }
17428 /*
17429 * Update the per-index indisreplident flags correctly.
17430 */
17433 {
17444 {
17445 /* Set the bit if not already set. */
17447 {
17450 }
17451 }
17452 else
17453 {
17454 /* Unset the bit if set. */
17456 {
17459 }
17460 }
17463 {
17468 /*
17469 * Invalidate the relcache for the table, so that after we commit
17470 * all sessions will refresh the table's replica identity index
17471 * before attempting any UPDATE or DELETE on the table. (If we
17472 * changed the table's pg_class row above, then a relcache inval
17473 * is already queued due to that; but we might not have.)
17474 */
17476 }
17478 }
17481 }
17483 /*
17484 * ALTER TABLE <name> REPLICA IDENTITY ...
17485 */
17486 static void
17488 {
17489 Oid indexOid;
17490 Relation indexRel;
17494 {
17497 }
17499 {
17502 }
17504 {
17507 }
17509 {
17511 }
17512 else
17515 /* Check that the index exists */
17525 /* Check that the index is on the relation we're altering. */
17533 /* The AM must support uniqueness, and the index must in fact be unique. */
17540 /* Deferred indexes are not guaranteed to be always unique. */
17546 /* Expression indexes aren't supported. */
17552 /* Predicate indexes aren't supported. */
17559 /* Check index for nullable columns. */
17561 {
17563 Form_pg_attribute attr;
17565 /*
17566 * Reject any other system columns. (Going forward, we'll disallow
17567 * indexes containing such columns in the first place, but they might
17568 * exist in older branches.)
17569 */
17573 errmsg("index \"%s\" cannot be used as replica identity because column %d is a system column",
17583 }
17585 /* This index is suitable for use as a replica identity. Mark it. */
17589 }
17591 /*
17592 * ALTER TABLE ENABLE/DISABLE ROW LEVEL SECURITY
17593 */
17594 static void
17596 {
17597 Relation pg_class;
17598 Oid relid;
17599 HeapTuple tuple;
17603 /* Pull the record for this relation and update it */
17619 }
17621 /*
17622 * ALTER TABLE FORCE/NO FORCE ROW LEVEL SECURITY
17623 */
17624 static void
17626 {
17627 Relation pg_class;
17628 Oid relid;
17629 HeapTuple tuple;
17648 }
17650 /*
17651 * ALTER FOREIGN TABLE <name> OPTIONS (...)
17652 */
17653 static void
17655 {
17656 Relation ftrel;
17659 HeapTuple tuple;
17664 Datum datum;
17665 Form_pg_foreign_table tableform;
17687 /* Extract the current options */
17689 tuple,
17690 Anum_pg_foreign_table_ftoptions,
17695 /* Transform the options */
17697 datum,
17698 options,
17703 else
17708 /* Everything looks good - update the tuple */
17715 /*
17716 * Invalidate relcache so that all sessions will refresh any cached plans
17717 * that might depend on the old options.
17718 */
17727 }
17729 /*
17730 * ALTER TABLE ALTER COLUMN SET COMPRESSION
17731 *
17732 * Return value is the address of the modified column
17733 */
17734 static ObjectAddress
17738 LOCKMODE lockmode)
17739 {
17740 Relation attrel;
17741 HeapTuple tuple;
17742 Form_pg_attribute atttableform;
17743 AttrNumber attnum;
17746 ObjectAddress address;
17752 /* copy the cache entry so we can scribble on it below */
17760 /* prevent them from altering a system attribute */
17768 /*
17769 * Check that column type is compressible, then get the attribute
17770 * compression method code
17771 */
17774 /* update pg_attribute entry */
17780 attnum);
17782 /*
17783 * Apply the change to indexes as well (only for simple index columns,
17784 * matching behavior of index.c ConstructTupleDescriptor()).
17785 */
17789 lockmode);
17795 /* make changes visible */
17801 }
17804 /*
17805 * Preparation phase for SET LOGGED/UNLOGGED
17806 *
17807 * This verifies that we're not trying to change a temp table. Also,
17808 * existing foreign key constraints are checked to avoid ending up with
17809 * permanent tables referencing unlogged tables.
17810 *
17811 * Return value is false if the operation is a no-op (in which case the
17812 * checks are skipped), otherwise true.
17813 */
17814 static bool
17816 {
17817 Relation pg_constraint;
17818 HeapTuple tuple;
17819 SysScanDesc scan;
17822 /*
17823 * Disallow changing status for a temp table. Also verify whether we can
17824 * get away with doing nothing; in such cases we don't need to run the
17825 * checks below, either.
17826 */
17828 {
17838 /* nothing to do */
17843 /* nothing to do */
17846 }
17848 /*
17849 * Check that the table is not part of any publication when changing to
17850 * UNLOGGED, as UNLOGGED tables can't be published.
17851 */
17860 /*
17861 * Check existing foreign key constraints to preserve the invariant that
17862 * permanent tables cannot reference unlogged ones. Self-referencing
17863 * foreign keys can safely be ignored.
17864 */
17867 /*
17868 * Scan conrelid if changing to permanent, else confrelid. This also
17869 * determines whether a useful index exists.
17870 */
17873 Anum_pg_constraint_confrelid,
17881 {
17885 {
17886 Oid foreignrelid;
17887 Relation foreignrel;
17889 /* the opposite end of what we used as scankey */
17892 /* ignore if self-referencing */
17899 {
17907 }
17908 else
17909 {
17917 }
17920 }
17921 }
17928 }
17930 /*
17931 * Execute ALTER TABLE SET SCHEMA
17932 */
17933 ObjectAddress
17935 {
17936 Relation rel;
17937 Oid relid;
17938 Oid oldNspOid;
17939 Oid nspOid;
17942 ObjectAddress myself;
17946 RangeVarCallbackForAlterRelation,
17950 {
17955 }
17961 /* If it's an owned sequence, disallow moving it by itself. */
17963 {
17964 Oid tableId;
17965 int32 colId;
17975 }
17977 /* Get and lock schema OID and check its permissions. */
17981 /* common checks on switching namespaces */
17993 /* close rel, but keep lock until commit */
17997 }
17999 /*
18000 * The guts of relocating a table or materialized view to another namespace:
18001 * besides moving the relation itself, its dependent objects are relocated to
18002 * the new schema.
18003 */
18004 void
18007 {
18008 Relation classRel;
18012 /* OK, modify the pg_class row and pg_depend entry */
18018 /* Fix the table's row type too, if it has one */
18024 objsMoved);
18026 /* Fix other dependent stuff */
18034 }
18036 /*
18037 * The guts of relocating a relation to another namespace: fix the pg_class
18038 * entry, and the pg_depend entry if any. Caller must already have
18039 * opened and write-locked pg_class.
18040 */
18041 void
18046 {
18047 HeapTuple classTup;
18048 Form_pg_class classForm;
18049 ObjectAddress thisobj;
18063 /*
18064 * If the object has already been moved, don't move it again. If it's
18065 * already in the right place, don't move it, but still fire the object
18066 * access hook.
18067 */
18070 {
18071 /* check for duplicate name (more friendly than unique-index failure) */
18080 /* classTup is a copy, so OK to scribble on */
18085 /* Update dependency on schema if caller said so */
18088 relOid,
18089 NamespaceRelationId,
18090 oldNspOid,
18094 }
18096 {
18100 }
18103 }
18105 /*
18106 * Move all indexes for the specified relation to another namespace.
18107 *
18108 * Note: we assume adequate permission checking was done by the caller,
18109 * and that the caller has a suitable lock on the owning relation.
18110 */
18111 static void
18114 {
18121 {
18123 ObjectAddress thisobj;
18129 /*
18130 * Note: currently, the index will not have its own dependency on the
18131 * namespace, so we don't need to do changeDependencyFor(). There's no
18132 * row type in pg_type, either.
18133 *
18134 * XXX this objsMoved test may be pointless -- surely we have a single
18135 * dependency link from a relation to each index?
18136 */
18138 {
18143 }
18144 }
18147 }
18149 /*
18150 * Move all identity and SERIAL-column sequences of the specified relation to another
18151 * namespace.
18152 *
18153 * Note: we assume adequate permission checking was done by the caller,
18154 * and that the caller has a suitable lock on the owning relation.
18155 */
18156 static void
18159 LOCKMODE lockmode)
18160 {
18161 Relation depRel;
18162 SysScanDesc scan;
18164 HeapTuple tup;
18166 /*
18167 * SERIAL sequences are those having an auto dependency on one of the
18168 * table's columns (we don't care *which* column, exactly).
18169 */
18173 Anum_pg_depend_refclassid,
18177 Anum_pg_depend_refobjid,
18180 /* we leave refobjsubid unspecified */
18186 {
18188 Relation seqRel;
18190 /* skip dependencies other than auto dependencies on columns */
18197 /* Use relation_open just in case it's an index */
18200 /* skip non-sequence relations */
18202 {
18203 /* No need to keep the lock */
18206 }
18208 /* Fix the pg_class and pg_depend entries */
18213 /*
18214 * Sequences used to have entries in pg_type, but no longer do. If we
18215 * ever re-instate that, we'll need to move the pg_type entry to the
18216 * new namespace, too (using AlterTypeNamespaceInternal).
18217 */
18220 /* Now we can close it. Keep the lock till end of transaction. */
18222 }
18227 }
18230 /*
18231 * This code supports
18232 * CREATE TEMP TABLE ... ON COMMIT { DROP | PRESERVE ROWS | DELETE ROWS }
18233 *
18234 * Because we only support this for TEMP tables, it's sufficient to remember
18235 * the state in a backend-local data structure.
18236 */
18238 /*
18239 * Register a newly-created relation's ON COMMIT action.
18240 */
18241 void
18243 {
18245 MemoryContext oldcxt;
18247 /*
18248 * We needn't bother registering the relation unless there is an ON COMMIT
18249 * action we need to take.
18250 */
18262 /*
18263 * We use lcons() here so that ON COMMIT actions are processed in reverse
18264 * order of registration. That might not be essential but it seems
18265 * reasonable.
18266 */
18270 }
18272 /*
18273 * Unregister any ON COMMIT action when a relation is deleted.
18274 *
18275 * Actually, we only mark the OnCommitItem entry as to be deleted after commit.
18276 */
18277 void
18279 {
18283 {
18287 {
18290 }
18291 }
18292 }
18294 /*
18295 * Perform ON COMMIT actions.
18296 *
18297 * This is invoked just before actually committing, since it's possible
18298 * to encounter errors.
18299 */
18300 void
18302 {
18308 {
18311 /* Ignore entry if already dropped in this xact */
18316 {
18319 /* Do nothing (there shouldn't be such entries, actually) */
18323 /*
18324 * If this transaction hasn't accessed any temporary
18325 * relations, we can skip truncating ON COMMIT DELETE ROWS
18326 * tables, as they must still be empty.
18327 */
18334 }
18335 }
18337 /*
18338 * Truncate relations before dropping so that all dependencies between
18339 * relations are removed after they are worked on. Doing it like this
18340 * might be a waste as it is possible that a relation being truncated will
18341 * be dropped anyway due to its parent being dropped, but this makes the
18342 * code more robust because of not having to re-check that the relation
18343 * exists at truncation time.
18344 */
18349 {
18353 {
18354 ObjectAddress object;
18363 }
18365 /*
18366 * Object deletion might involve toast table access (to clean up
18367 * toasted catalog entries), so ensure we have a valid snapshot.
18368 */
18371 /*
18372 * Since this is an automatic drop, rather than one directly initiated
18373 * by the user, we pass the PERFORM_DELETION_INTERNAL flag.
18374 */
18380 #ifdef USE_ASSERT_CHECKING
18382 /*
18383 * Note that table deletion will call remove_on_commit_action, so the
18384 * entry should get marked as deleted.
18385 */
18387 {
18394 }
18395 #endif
18396 }
18397 }
18399 /*
18400 * Post-commit or post-abort cleanup for ON COMMIT management.
18401 *
18402 * All we do here is remove no-longer-needed OnCommitItem entries.
18403 *
18404 * During commit, remove entries that were deleted during this transaction;
18405 * during abort, remove those created during this transaction.
18406 */
18407 void
18409 {
18413 {
18418 {
18419 /* cur_item must be removed */
18422 }
18423 else
18424 {
18425 /* cur_item must be preserved */
18428 }
18429 }
18430 }
18432 /*
18433 * Post-subcommit or post-subabort cleanup for ON COMMIT management.
18434 *
18435 * During subabort, we can immediately remove entries created during this
18436 * subtransaction. During subcommit, just relabel entries marked during
18437 * this subtransaction as being the parent's responsibility.
18438 */
18439 void
18441 SubTransactionId parentSubid)
18442 {
18446 {
18450 {
18451 /* cur_item must be removed */
18454 }
18455 else
18456 {
18457 /* cur_item must be preserved */
18462 }
18463 }
18464 }
18466 /*
18467 * This is intended as a callback for RangeVarGetRelidExtended(). It allows
18468 * the relation to be locked only if (1) it's a plain or partitioned table,
18469 * materialized view, or TOAST table and (2) the current user is the owner (or
18470 * the superuser) or has been granted MAINTAIN. This meets the
18471 * permission-checking needs of CLUSTER, REINDEX TABLE, and REFRESH
18472 * MATERIALIZED VIEW; we expose it here so that it can be used by all.
18473 */
18474 void
18477 {
18479 AclResult aclresult;
18481 /* Nothing to do if the relation was not found. */
18485 /*
18486 * If the relation does exist, check whether it's an index. But note that
18487 * the relation might have been dropped between the time we did the name
18488 * lookup and now. In that case, there's nothing to do.
18489 */
18499 /* Check permissions */
18505 }
18507 /*
18508 * Callback to RangeVarGetRelidExtended() for TRUNCATE processing.
18509 */
18510 static void
18513 {
18514 HeapTuple tuple;
18516 /* Nothing to do if the relation was not found. */
18528 }
18530 /*
18531 * Callback for RangeVarGetRelidExtended(). Checks that the current user is
18532 * the owner of the relation, or superuser.
18533 */
18534 void
18537 {
18538 HeapTuple tuple;
18540 /* Nothing to do if the relation was not found. */
18560 }
18562 /*
18563 * Common RangeVarGetRelid callback for rename, set schema, and alter table
18564 * processing.
18565 */
18566 static void
18569 {
18571 ObjectType reltype;
18572 HeapTuple tuple;
18573 Form_pg_class classform;
18574 AclResult aclresult;
18583 /* Must own relation. */
18587 /* No system table modifications unless explicitly allowed. */
18594 /*
18595 * Extract the specified relation type from the statement parse tree.
18596 *
18597 * Also, for ALTER .. RENAME, check permissions: the user must (still)
18598 * have CREATE rights on the containing namespace.
18599 */
18601 {
18608 }
18614 else
18615 {
18618 }
18620 /*
18621 * For compatibility with prior releases, we allow ALTER TABLE to be used
18622 * with most other types of relations (but not composite types). We allow
18623 * similar flexibility for ALTER INDEX in the case of RENAME, but not
18624 * otherwise. Otherwise, the user must select the correct form of the
18625 * command for the relation at issue.
18626 */
18653 relkind != RELKIND_PARTITIONED_INDEX
18659 /*
18660 * Don't allow ALTER TABLE on composite types. We want people to use ALTER
18661 * TYPE for that.
18662 */
18667 /* translator: %s is an SQL ALTER command */
18671 /*
18672 * Don't allow ALTER TABLE .. SET SCHEMA on relations that can't be moved
18673 * to a different schema, such as indexes and TOAST tables.
18674 */
18676 {
18688 /* translator: %s is an SQL ALTER command */
18697 }
18700 }
18702 /*
18703 * Transform any expressions present in the partition key
18704 *
18705 * Returns a transformed PartitionSpec.
18706 */
18709 {
18721 /* Check valid number of columns for strategy */
18728 /*
18729 * Create a dummy ParseState and insert the target relation as its sole
18730 * rangetable entry. We need a ParseState for transformExpr.
18731 */
18737 /* take care of any partition expressions */
18739 {
18743 {
18744 /* Copy, to avoid scribbling on the input */
18747 /* Now do parse transformation of the expression */
18749 EXPR_KIND_PARTITION_EXPRESSION);
18751 /* we have to fix its collations too */
18753 }
18756 }
18759 }
18761 /*
18762 * Compute per-partition-column information from a list of PartitionElems.
18763 * Expressions in the PartitionElems must be parse-analyzed already.
18764 */
18765 static void
18766 ComputePartitionAttrs(ParseState *pstate, Relation rel, List *partParams, AttrNumber *partattrs,
18768 PartitionStrategy strategy)
18769 {
18772 Oid am_oid;
18776 {
18778 Oid atttype;
18779 Oid attcollation;
18782 {
18783 /* Simple attribute reference */
18784 HeapTuple atttuple;
18785 Form_pg_attribute attform;
18804 /*
18805 * Generated columns cannot work: They are computed after BEFORE
18806 * triggers, but partition routing is done before all triggers.
18807 */
18820 }
18821 else
18822 {
18823 /* Expression */
18831 /*
18832 * The expression must be of a storable type (e.g., not RECORD).
18833 * The test is the same as for whether a table column is of a safe
18834 * type (which is why we needn't check for the non-expression
18835 * case).
18836 */
18842 /*
18843 * Strip any top-level COLLATE clause. This ensures that we treat
18844 * "x COLLATE y" and "(x COLLATE y)" alike.
18845 */
18851 {
18852 /*
18853 * User wrote "(column)" or "(column COLLATE something)".
18854 * Treat it like simple attribute anyway.
18855 */
18857 }
18858 else
18859 {
18866 /*
18867 * transformPartitionSpec() should have already rejected
18868 * subqueries, aggregates, window functions, and SRFs, based
18869 * on the EXPR_KIND_ for partition expressions.
18870 */
18872 /*
18873 * Cannot allow system column references, since that would
18874 * make partition routing impossible: their values won't be
18875 * known yet when we need to do that.
18876 */
18879 {
18881 expr_attrs))
18885 }
18887 /*
18888 * Generated columns cannot work: They are computed after
18889 * BEFORE triggers, but partition routing is done before all
18890 * triggers.
18891 */
18894 {
18905 }
18907 /*
18908 * Preprocess the expression before checking for mutability.
18909 * This is essential for the reasons described in
18910 * contain_mutable_functions_after_planning. However, we call
18911 * expression_planner for ourselves rather than using that
18912 * function, because if constant-folding reduces the
18913 * expression to a constant, we'd like to know that so we can
18914 * complain below.
18915 *
18916 * Like contain_mutable_functions_after_planning, assume that
18917 * expression_planner won't scribble on its input, so this
18918 * won't affect the partexprs entry we saved above.
18919 */
18922 /*
18923 * Partition expressions cannot contain mutable functions,
18924 * because a given row must always map to the same partition
18925 * as long as there is no change in the partition boundary
18926 * structure.
18927 */
18933 /*
18934 * While it is not exactly *wrong* for a partition expression
18935 * to be a constant, it seems better to reject such keys.
18936 */
18941 }
18942 }
18944 /*
18945 * Apply collation override if any
18946 */
18950 /*
18951 * Check we have a collation iff it's a collatable type. The only
18952 * expected failures here are (1) COLLATE applied to a noncollatable
18953 * type, or (2) partition expression had an unresolved collation. But
18954 * we might as well code this to be a complete consistency check.
18955 */
18957 {
18963 }
18964 else
18965 {
18971 }
18975 /*
18976 * Identify the appropriate operator class. For list and range
18977 * partitioning, we use a btree operator class; hash partitioning uses
18978 * a hash operator class.
18979 */
18982 else
18986 {
18990 {
18996 errhint("You must specify a hash operator class or define a default hash operator class for the data type.")));
18997 else
19002 errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
19003 }
19004 }
19005 else
19007 atttype,
19009 am_oid);
19011 attn++;
19012 }
19013 }
19015 /*
19016 * PartConstraintImpliedByRelConstraint
19017 * Do scanrel's existing constraints imply the partition constraint?
19018 *
19019 * "Existing constraints" include its check constraints and column-level
19020 * not-null constraints. partConstraint describes the partition constraint,
19021 * in implicit-AND form.
19022 */
19023 bool
19026 {
19032 {
19036 {
19040 {
19044 i,
19051 /*
19052 * argisrow=false is correct even for a composite column,
19053 * because attnotnull does not represent a SQL-spec IS NOT
19054 * NULL test in such a case, just IS DISTINCT FROM NULL.
19055 */
19059 }
19060 }
19061 }
19064 }
19066 /*
19067 * ConstraintImpliedByRelConstraint
19068 * Do scanrel's existing constraints imply the given constraint?
19069 *
19070 * testConstraint is the constraint to validate. provenConstraint is a
19071 * caller-provided list of conditions which this function may assume
19072 * to be true. Both provenConstraint and testConstraint must be in
19073 * implicit-AND form, must only contain immutable clauses, and must
19074 * contain only Vars with varno = 1.
19075 */
19076 bool
19077 ConstraintImpliedByRelConstraint(Relation scanrel, List *testConstraint, List *provenConstraint)
19078 {
19082 i;
19086 {
19089 /*
19090 * If this constraint hasn't been fully validated yet, we must ignore
19091 * it here.
19092 */
19098 /*
19099 * Run each expression through const-simplification and
19100 * canonicalization. It is necessary, because we will be comparing it
19101 * to similarly-processed partition constraint expressions, and may
19102 * fail to detect valid matches without this.
19103 */
19109 }
19111 /*
19112 * Try to make the proof. Since we are comparing CHECK constraints, we
19113 * need to use weak implication, i.e., we assume existConstraint is
19114 * not-false and try to prove the same for testConstraint.
19115 *
19116 * Note that predicate_implied_by assumes its first argument is known
19117 * immutable. That should always be true for both NOT NULL and partition
19118 * constraints, so we don't test it here.
19119 */
19121 }
19123 /*
19124 * QueuePartitionConstraintValidation
19125 *
19126 * Add an entry to wqueue to have the given partition constraint validated by
19127 * Phase 3, for the given relation, and all its children.
19128 *
19129 * We first verify whether the given constraint is implied by pre-existing
19130 * relation constraints; if it is, there's no need to scan the table to
19131 * validate, so don't queue in that case.
19132 */
19133 static void
19137 {
19138 /*
19139 * Based on the table's existing constraints, determine whether or not we
19140 * may skip scanning the table.
19141 */
19143 {
19148 else
19150 (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
19153 }
19155 /*
19156 * Constraints proved insufficient. For plain relations, queue a
19157 * validation item now; for partitioned tables, recurse to process each
19158 * partition.
19159 */
19161 {
19164 /* Grab a work queue entry. */
19169 }
19171 {
19176 {
19177 Relation part_rel;
19180 /*
19181 * This is the minimum lock we need to prevent deadlocks.
19182 */
19185 /*
19186 * Adjust the constraint for scanrel so that it matches this
19187 * partition's attribute numbers.
19188 */
19189 thisPartConstraint =
19194 thisPartConstraint,
19195 validate_default);
19197 }
19198 }
19199 }
19201 /*
19202 * attachPartitionTable: attach a new partition to the partitioned table
19203 *
19204 * wqueue: the ALTER TABLE work queue; can be NULL when not running as part
19205 * of an ALTER TABLE sequence.
19206 * rel: partitioned relation;
19207 * attachrel: relation of attached partition;
19208 * bound: bounds of attached relation.
19209 */
19210 static void
19211 attachPartitionTable(List **wqueue, Relation rel, Relation attachrel, PartitionBoundSpec *bound)
19212 {
19213 /* OK to create inheritance. Rest of the checks performed there */
19216 /* Update the pg_class entry. */
19219 /* Ensure there exists a correct set of indexes in the partition. */
19222 /* and triggers */
19225 /*
19226 * Clone foreign key constraints. Callee is responsible for setting up
19227 * for phase 3 constraint verification.
19228 */
19230 }
19232 /*
19233 * ALTER TABLE <name> ATTACH PARTITION <partition-name> FOR VALUES
19234 *
19235 * Return the address of the newly attached partition.
19236 */
19237 static ObjectAddress
19240 {
19241 Relation attachrel,
19242 catalog;
19245 SysScanDesc scan;
19246 ScanKeyData skey;
19247 AttrNumber attno;
19249 TupleDesc tupleDesc;
19250 ObjectAddress address;
19252 Oid defaultPartOid;
19258 /*
19259 * We must lock the default partition if one exists, because attaching a
19260 * new partition will change its partition constraint.
19261 */
19262 defaultPartOid =
19269 /*
19270 * XXX I think it'd be a good idea to grab locks on all tables referenced
19271 * by FKs at this point also.
19272 */
19274 /*
19275 * Must be owner of both parent and source table -- parent was checked by
19276 * ATSimplePermissions call in ATPrepCmd
19277 */
19280 /* A partition can only have one parent */
19292 /*
19293 * Table being attached should not already be part of inheritance; either
19294 * as a child table...
19295 */
19298 Anum_pg_inherits_inhrelid,
19309 /* ...or as a parent table (except the case when it is partitioned) */
19311 Anum_pg_inherits_inhparent,
19324 /*
19325 * Prevent circularity by seeing if rel is a partition of attachrel. (In
19326 * particular, this disallows making a rel a partition of itself.)
19327 *
19328 * We do that by checking if rel is a member of the list of attachrel's
19329 * partitions provided the latter is partitioned at all. We want to avoid
19330 * having to construct this list again, so we request the strongest lock
19331 * on all partitions. We need the strongest lock, because we may decide
19332 * to scan them if we find out that the table being attached (or its leaf
19333 * partitions) may contain rows that violate the partition constraint. If
19334 * the table has a constraint that would prevent such rows, which by
19335 * definition is present in all the partitions, we need not scan the
19336 * table, nor its partitions. But we cannot risk a deadlock by taking a
19337 * weaker lock now and the stronger one only when needed.
19338 */
19349 /* If the parent is permanent, so must be all of its partitions. */
19357 /* Temp parent cannot have a partition that is itself not a temp */
19365 /* If the parent is temp, it must belong to this session */
19372 /* Ditto for the partition */
19379 /*
19380 * Check if attachrel has any identity columns or any columns that aren't
19381 * in the parent.
19382 */
19386 {
19390 /* Ignore dropped */
19401 /* Try to find the column in parent (matching on column name) */
19411 }
19413 /*
19414 * If child_rel has row-level triggers with transition tables, we
19415 * currently don't allow it to become a partition. See also prohibitions
19416 * in ATExecAddInherit() and CreateTrigger().
19417 */
19426 /*
19427 * Check that the new partition's bound is valid and does not overlap any
19428 * of existing partitions of the parent - note that it does not return on
19429 * error.
19430 */
19434 /* Attach a new partition to the partitioned table. */
19437 /*
19438 * Generate partition constraint from the partition bound specification.
19439 * If the parent itself is a partition, make sure to include its
19440 * constraint as well.
19441 */
19446 /* Skip validation if there are no constraints to validate. */
19448 {
19449 /*
19450 * Run the partition quals through const-simplification similar to
19451 * check constraints. We skip canonicalize_qual, though, because
19452 * partition quals should be in canonical form already.
19453 */
19454 partConstraint =
19458 /* XXX this sure looks wrong */
19461 /*
19462 * Adjust the generated constraint to match this partition's attribute
19463 * numbers.
19464 */
19466 rel);
19468 /* Validate partition constraints against the table being attached. */
19471 }
19473 /*
19474 * If we're attaching a partition other than the default partition and a
19475 * default one exists, then that partition's partition constraint changes,
19476 * so add an entry to the work queue to validate it, too. (We must not do
19477 * this when the partition being attached is the default one; we already
19478 * did it above!)
19479 */
19481 {
19482 Relation defaultrel;
19487 /* we already hold a lock on the default partition */
19489 defPartConstraint =
19492 /*
19493 * Map the Vars in the constraint expression from rel's attnos to
19494 * defaultrel's.
19495 */
19496 defPartConstraint =
19502 /* keep our lock until commit. */
19504 }
19508 /*
19509 * If the partition we just attached is partitioned itself, invalidate
19510 * relcache for all descendent partitions too to ensure that their
19511 * rd_partcheck expression trees are rebuilt; partitions already locked at
19512 * the beginning of this function.
19513 */
19515 {
19519 {
19521 }
19522 }
19524 /* keep our lock until commit */
19528 }
19530 /*
19531 * AttachPartitionEnsureIndexes
19532 * subroutine for ATExecAttachPartition to create/match indexes
19533 *
19534 * Enforce the indexing rule for partitioned tables during ALTER TABLE / ATTACH
19535 * PARTITION: every partition must have an index attached to each index on the
19536 * partitioned table.
19537 */
19538 static void
19540 {
19546 MemoryContext cxt;
19547 MemoryContext oldcxt;
19551 ALLOCSET_DEFAULT_SIZES);
19559 /* Build arrays of all existing indexes and their IndexInfos */
19561 {
19567 }
19569 /*
19570 * If we're attaching a foreign table, we must fail if any of the indexes
19571 * is a constraint index; otherwise, there's nothing to do here. Do this
19572 * before starting work, to avoid wasting the effort of building a few
19573 * non-unique indexes before coming across a unique one.
19574 */
19576 {
19578 {
19592 }
19595 }
19597 /*
19598 * For each index on the partitioned table, find a matching one in the
19599 * partition-to-be; if one is not found, create one.
19600 */
19602 {
19608 Oid constraintOid;
19610 /*
19611 * Ignore indexes in the partitioned table other than partitioned
19612 * indexes.
19613 */
19615 {
19618 }
19620 /* construct an indexinfo to compare existing indexes against */
19627 /*
19628 * Scan the list of existing indexes in the partition-to-be, and mark
19629 * the first matching, valid, unattached one we find, if any, as
19630 * partition of the parent index. If we find one, we're done.
19631 */
19633 {
19637 /* does this index have a parent? if so, can't use it */
19641 /* If this index is invalid, can't use it */
19650 attmap))
19651 {
19652 /*
19653 * If this index is being created in the parent because of a
19654 * constraint, then the child needs to have a constraint also,
19655 * so look for one. If there is no such constraint, this
19656 * index is no good, so keep looking.
19657 */
19659 {
19660 cldConstrOid =
19662 cldIdxId);
19663 /* no dice */
19667 /* Ensure they're both the same type of constraint */
19671 }
19673 /* bingo. */
19682 }
19683 }
19685 /*
19686 * If no suitable index was found in the partition-to-be, create one
19687 * now.
19688 */
19690 {
19692 Oid conOid;
19698 /*
19699 * If the index is a primary key, mark all columns as NOT NULL if
19700 * they aren't already.
19701 */
19703 {
19706 {
19707 AttrNumber childattno;
19715 }
19717 }
19721 conOid,
19724 }
19727 }
19729 out:
19730 /* Clean up. */
19735 }
19737 /*
19738 * CloneRowTriggersToPartition
19739 * subroutine for ATExecAttachPartition/DefineRelation to create row
19740 * triggers on partitions
19741 */
19742 static void
19744 {
19745 Relation pg_trigger;
19746 ScanKeyData key;
19747 SysScanDesc scan;
19748 HeapTuple tuple;
19749 MemoryContext perTupCxt;
19761 {
19765 Datum value;
19769 MemoryContext oldcxt;
19771 /*
19772 * Ignore statement-level triggers; those are not cloned.
19773 */
19777 /*
19778 * Don't clone internal triggers, because the constraint cloning code
19779 * will.
19780 */
19784 /*
19785 * Complain if we find an unexpected trigger type.
19786 */
19792 /* Use short-lived context for CREATE TRIGGER */
19795 /*
19796 * If there is a WHEN clause, generate a 'cooked' version of it that's
19797 * appropriate for the partition.
19798 */
19802 {
19808 }
19810 /*
19811 * If there is a column list, transform it to a list of column names.
19812 * Note we don't need to map this list in any way ...
19813 */
19815 {
19819 {
19820 Form_pg_attribute col;
19826 }
19827 }
19829 /* Reconstruct trigger arguments list. */
19831 {
19843 {
19846 }
19847 }
19873 }
19879 }
19881 /*
19882 * ALTER TABLE DETACH PARTITION
19883 *
19884 * Return the address of the relation that is no longer a partition of rel.
19885 *
19886 * If concurrent mode is requested, we run in two transactions. A side-
19887 * effect is that this command cannot run in a multi-part ALTER TABLE.
19888 * Currently, that's enforced by the grammar.
19889 *
19890 * The strategy for concurrency is to first modify the partition's
19891 * pg_inherit catalog row to make it visible to everyone that the
19892 * partition is detached, lock the partition against writes, and commit
19893 * the transaction; anyone who requests the partition descriptor from
19894 * that point onwards has to ignore such a partition. In a second
19895 * transaction, we wait until all transactions that could have seen the
19896 * partition as attached are gone, then we remove the rest of partition
19897 * metadata (pg_inherits and pg_class.relpartbounds).
19898 */
19899 static ObjectAddress
19902 {
19903 Relation partRel;
19904 ObjectAddress address;
19905 Oid defaultPartOid;
19907 /*
19908 * We must lock the default partition, because detaching this partition
19909 * will change its partition constraint.
19910 */
19911 defaultPartOid =
19914 {
19915 /*
19916 * Concurrent detaching when a default partition exists is not
19917 * supported. The main problem is that the default partition
19918 * constraint would change. And there's a definitional problem: what
19919 * should happen to the tuples that are being inserted that belong to
19920 * the partition being detached? Putting them on the partition being
19921 * detached would be wrong, since they'd become "lost" after the
19922 * detaching completes but we cannot put them in the default partition
19923 * either until we alter its partition constraint.
19924 *
19925 * I think we could solve this problem if we effected the constraint
19926 * change before committing the first transaction. But the lock would
19927 * have to remain AEL and it would cause concurrent query planning to
19928 * be blocked, so changing it that way would be even worse.
19929 */
19935 }
19937 /*
19938 * In concurrent mode, the partition is locked with share-update-exclusive
19939 * in the first transaction. This allows concurrent transactions to be
19940 * doing DML to the partition.
19941 */
19943 AccessExclusiveLock);
19945 /*
19946 * Check inheritance conditions and either delete the pg_inherits row (in
19947 * non-concurrent mode) or just set the inhdetachpending flag.
19948 */
19951 else
19954 /*
19955 * Ensure that foreign keys still hold after this detach. This keeps
19956 * locks on the referencing tables, which prevents concurrent transactions
19957 * from adding rows that we wouldn't see. For this to work in concurrent
19958 * mode, it is critical that the partition appears as no longer attached
19959 * for the RI queries as soon as the first transaction commits.
19960 */
19963 /*
19964 * Concurrent mode has to work harder; first we add a new constraint to
19965 * the partition that matches the partition constraint. Then we close our
19966 * existing transaction, and in a new one wait for all processes to catch
19967 * up on the catalog updates we've done so far; at that point we can
19968 * complete the operation.
19969 */
19971 {
19972 Oid partrelid,
19973 parentrelid;
19974 LOCKTAG tag;
19978 /*
19979 * Add a new constraint to the partition being detached, which
19980 * supplants the partition constraint (unless there is one already).
19981 */
19984 /*
19985 * We're almost done now; the only traces that remain are the
19986 * pg_inherits tuple and the partition's relpartbounds. Before we can
19987 * remove those, we need to wait until all transactions that know that
19988 * this is a partition are gone.
19989 */
19991 /*
19992 * Remember relation OIDs to re-acquire them later; and relation names
19993 * too, for error messages if something is dropped in between.
19994 */
20002 /* Invalidate relcache entries for the parent -- must be before close */
20009 /* Make updated catalog entry visible */
20015 /*
20016 * Now wait. This ensures that all queries that were planned
20017 * including the partition are finished before we remove the rest of
20018 * catalog entries. We don't need or indeed want to acquire this
20019 * lock, though -- that would block later queries.
20020 *
20021 * We don't need to concern ourselves with waiting for a lock on the
20022 * partition itself, since we will acquire AccessExclusiveLock below.
20023 */
20027 /*
20028 * Now acquire locks in both relations again. Note they may have been
20029 * removed in the meantime, so care is required.
20030 */
20034 /* If the relations aren't there, something bad happened; bail out */
20036 {
20039 partrelname);
20043 parentrelname)));
20044 }
20051 }
20053 /* Do the final part of detaching */
20058 /* keep our lock until commit */
20062 }
20064 /*
20065 * Second part of ALTER TABLE .. DETACH.
20066 *
20067 * This is separate so that it can be run independently when the second
20068 * transaction of the concurrent algorithm fails (crash or abort).
20069 */
20070 static void
20072 Oid defaultPartOid)
20073 {
20074 Relation classRel;
20081 HeapTuple tuple,
20082 newtuple;
20086 {
20087 /*
20088 * We can remove the pg_inherits row now. (In the non-concurrent case,
20089 * this was already done).
20090 */
20092 }
20094 /* Drop any triggers that were cloned on creation/attach. */
20097 /*
20098 * Detach any foreign keys that are inherited. This includes creating
20099 * additional action triggers.
20100 */
20105 {
20107 HeapTuple contup;
20108 Form_pg_constraint conform;
20110 Oid insertTriggerOid,
20111 updateTriggerOid;
20118 /* consider only the inherited foreign keys */
20121 {
20124 }
20126 /* unset conparentid and adjust conislocal, coninhcount, etc. */
20129 /*
20130 * Also, look up the partition's "check" triggers corresponding to the
20131 * constraint being detached and detach them from the parent triggers.
20132 */
20143 /*
20144 * Make the action triggers on the referenced relation. When this was
20145 * a partition the action triggers pointed to the parent rel (they
20146 * still do), but now we need separate ones of our own.
20147 */
20173 }
20178 /*
20179 * Any sub-constraints that are in the referenced-side of a larger
20180 * constraint have to be removed. This partition is no longer part of the
20181 * key space of the constraint.
20182 */
20184 {
20186 ObjectAddress constraint;
20190 constrOid,
20191 ConstraintRelationId,
20192 DEPENDENCY_INTERNAL);
20197 }
20199 /* Now we can detach indexes */
20202 {
20204 Relation idx;
20205 Oid constrOid;
20216 /* If there's a constraint associated with the index, detach it too */
20218 idxid);
20223 }
20225 /* Update pg_class tuple */
20234 /* Clear relpartbound and reset relispartition */
20249 /*
20250 * Drop identity property from all identity columns of partition.
20251 */
20253 {
20259 }
20262 {
20263 /*
20264 * If the relation being detached is the default partition itself,
20265 * remove it from the parent's pg_partitioned_table entry.
20266 *
20267 * If not, we must invalidate default partition's relcache entry, as
20268 * in StorePartitionBound: its partition constraint depends on every
20269 * other partition's partition constraint.
20270 */
20273 else
20275 }
20277 /*
20278 * Invalidate the parent's relcache so that the partition is no longer
20279 * included in its partition descriptor.
20280 */
20283 /*
20284 * If the partition we just detached is partitioned itself, invalidate
20285 * relcache for all descendent partitions too to ensure that their
20286 * rd_partcheck expression trees are rebuilt; must lock partitions before
20287 * doing so, using the same lockmode as what partRel has been locked with
20288 * by the caller.
20289 */
20291 {
20297 {
20299 }
20300 }
20301 }
20303 /*
20304 * ALTER TABLE ... DETACH PARTITION ... FINALIZE
20305 *
20306 * To use when a DETACH PARTITION command previously did not run to
20307 * completion; this completes the detaching process.
20308 */
20309 static ObjectAddress
20311 {
20312 Relation partRel;
20313 ObjectAddress address;
20318 /*
20319 * Wait until existing snapshots are gone. This is important if the
20320 * second transaction of DETACH PARTITION CONCURRENTLY is canceled: the
20321 * user could immediately run DETACH FINALIZE without actually waiting for
20322 * existing transactions. We must not complete the detach action until
20323 * all such queries are complete (otherwise we would present them with an
20324 * inconsistent view of catalogs).
20325 */
20335 }
20337 /*
20338 * DetachAddConstraintIfNeeded
20339 * Subroutine for ATExecDetachPartition. Create a constraint that
20340 * takes the place of the partition constraint, but avoid creating
20341 * a dupe if a constraint already exists which implies the needed
20342 * constraint.
20343 */
20344 static void
20346 {
20352 /*
20353 * Avoid adding a new constraint if the needed constraint is implied by an
20354 * existing constraint
20355 */
20357 {
20363 /* Add constraint on partition, equivalent to the partition constraint */
20373 /* It's a re-add, since it nominally already exists */
20376 }
20377 }
20379 /*
20380 * DropClonedTriggersFromPartition
20381 * subroutine for ATExecDetachPartition to remove any triggers that were
20382 * cloned to the partition when it was created-as-partition or attached.
20383 * This undoes what CloneRowTriggersToPartition did.
20384 */
20385 static void
20387 {
20388 ScanKeyData skey;
20389 SysScanDesc scan;
20390 HeapTuple trigtup;
20391 Relation tgrel;
20396 /*
20397 * Scan pg_trigger to search for all triggers on this rel.
20398 */
20405 {
20407 ObjectAddress trig;
20409 /* Ignore triggers that weren't cloned */
20413 /*
20414 * Ignore internal triggers that are implementation objects of foreign
20415 * keys, because these will be detached when the foreign keys
20416 * themselves are.
20417 */
20421 /*
20422 * This is ugly, but necessary: remove the dependency markings on the
20423 * trigger so that it can be removed.
20424 */
20426 TriggerRelationId,
20427 DEPENDENCY_PARTITION_PRI);
20429 RelationRelationId,
20430 DEPENDENCY_PARTITION_SEC);
20432 /* remember this trigger to remove it below */
20435 }
20437 /* make the dependency removal visible to the deletion below */
20441 /* done */
20445 }
20447 /*
20448 * Before acquiring lock on an index, acquire the same lock on the owning
20449 * table.
20450 */
20451 struct AttachIndexCallbackState
20452 {
20453 Oid partitionOid;
20454 Oid parentTblOid;
20456 };
20458 static void
20461 {
20463 Form_pg_class classform;
20464 HeapTuple tuple;
20469 {
20472 }
20474 /*
20475 * If we previously locked some other heap, and the name we're looking up
20476 * no longer refers to an index on that relation, release the now-useless
20477 * lock. XXX maybe we should do *after* we verify whether the index does
20478 * not actually belong to the same relation ...
20479 */
20481 {
20484 }
20486 /* Didn't find a relation, so no need for locking or permission checks. */
20501 /*
20502 * Since we need only examine the heap's tupledesc, an access share lock
20503 * on it (preventing any DDL) is sufficient.
20504 */
20507 }
20509 /*
20510 * ALTER INDEX i1 ATTACH PARTITION i2
20511 */
20512 static ObjectAddress
20514 {
20515 Relation partIdx;
20516 Relation partTbl;
20517 Relation parentTbl;
20518 ObjectAddress address;
20519 Oid partIdxId;
20520 Oid currParent;
20523 /*
20524 * We need to obtain lock on the index 'name' to modify it, but we also
20525 * need to read its owning table's tuple descriptor -- so we need to lock
20526 * both. To avoid deadlocks, obtain lock on the table before doing so on
20527 * the index. Furthermore, we need to examine the parent table of the
20528 * partition, so lock that one too.
20529 */
20533 partIdxId =
20535 RangeVarCallbackForAttachIndex,
20537 /* Not there? */
20543 /* no deadlock risk: RangeVarGetRelidExtended already acquired the lock */
20546 /* we already hold locks on both tables, so this is safe: */
20552 /* Silently do nothing if already in the right state */
20556 {
20562 PartitionDesc partDesc;
20563 Oid constraintOid,
20566 /*
20567 * If this partition already has an index attached, refuse the
20568 * operation.
20569 */
20581 /* Make sure it indexes a partition of the other index's table */
20585 {
20587 {
20590 }
20591 }
20602 /* Ensure the indexes are compatible */
20613 attmap))
20621 /*
20622 * If there is a constraint in the parent, make sure there is one in
20623 * the child too.
20624 */
20629 {
20631 partIdxId);
20638 errdetail("The index \"%s\" belongs to a constraint in table \"%s\" but no constraint exists for index \"%s\".",
20642 }
20644 /*
20645 * If it's a primary key, make sure the columns in the partition are
20646 * NOT NULL.
20647 */
20651 /* All good -- do it */
20660 }
20663 /* keep these locks till commit */
20668 }
20670 /*
20671 * Verify whether the given partition already contains an index attached
20672 * to the given partitioned index. If so, raise an error.
20673 */
20674 static void
20676 {
20677 Oid existingIdx;
20689 }
20691 /*
20692 * Verify whether the set of attached partition indexes to a parent index on
20693 * a partitioned table is complete. If it is, mark the parent index valid.
20694 *
20695 * This should be called each time a partition index is attached.
20696 */
20697 static void
20699 {
20700 Relation inheritsRel;
20701 SysScanDesc scan;
20702 ScanKeyData key;
20704 HeapTuple inhTup;
20709 /*
20710 * Scan pg_inherits for this parent index. Count each valid index we find
20711 * (verifying the pg_index entry for each), and if we reach the total
20712 * amount we expect, we can mark this parent index as valid.
20713 */
20721 {
20723 HeapTuple indTup;
20724 Form_pg_index indexForm;
20734 }
20736 /* Done with pg_inherits */
20740 /*
20741 * If we found as many inherited indexes as the partitioned table has
20742 * partitions, we're good; update pg_index to set indisvalid.
20743 */
20745 {
20746 Relation idxRel;
20747 HeapTuple indTup;
20748 Form_pg_index indexForm;
20765 }
20767 /*
20768 * If this index is in turn a partition of a larger index, validating it
20769 * might cause the parent to become valid also. Try that.
20770 */
20772 {
20773 Oid parentIdxId,
20774 parentTblId;
20775 Relation parentIdx,
20776 parentTbl;
20778 /* make sure we see the validation we just did */
20791 }
20792 }
20794 /*
20795 * When attaching an index as a partition of a partitioned index which is a
20796 * primary key, verify that all the columns in the partition are marked NOT
20797 * NULL.
20798 */
20799 static void
20801 {
20803 {
20814 }
20815 }
20817 /*
20818 * Return an OID list of constraints that reference the given relation
20819 * that are marked as having a parent constraints.
20820 */
20823 {
20824 Relation pg_constraint;
20825 HeapTuple tuple;
20826 SysScanDesc scan;
20830 /*
20831 * If no indexes, or no columns are referenceable by FKs, we can avoid the
20832 * scan.
20833 */
20836 INDEX_ATTR_BITMAP_KEY)))
20839 /* Search for constraints referencing this table */
20848 /* XXX This is a seqscan, as we don't have a usable index */
20851 {
20854 /*
20855 * We only need to process constraints that are part of larger ones.
20856 */
20861 }
20867 }
20869 /*
20870 * During DETACH PARTITION, verify that any foreign keys pointing to the
20871 * partitioned table would not become invalid. An error is raised if any
20872 * referenced values exist.
20873 */
20874 static void
20876 {
20883 {
20885 HeapTuple tuple;
20886 Form_pg_constraint constrForm;
20887 Relation rel;
20898 /* prevent data changes into the referencing table until commit */
20910 /* we needn't fill in remaining fields */
20917 }
20918 }
20920 /*
20921 * resolve column compression specification to compression method.
20922 */
20923 static char
20925 {
20931 /*
20932 * To specify a nondefault method, the column data type must be toastable.
20933 * Note this says nothing about whether the column's attstorage setting
20934 * permits compression; we intentionally allow attstorage and
20935 * attcompression to be independent. But with a non-toastable type,
20936 * attstorage could not be set to a value that would permit compression.
20937 *
20938 * We don't actually need to enforce this, since nothing bad would happen
20939 * if attcompression were non-default; it would never be consulted. But
20940 * it seems more user-friendly to complain about a certainly-useless
20941 * attempt to set the property.
20942 */
20956 }
20958 /*
20959 * resolve column storage specification
20960 */
20961 static char
20963 {
20976 else
20980 storagemode)));
20982 /*
20983 * safety check: do not allow toasted storage modes unless column datatype
20984 * is TOAST-aware.
20985 */
20993 }
20995 /*
20996 * Struct with context of new partition for inserting rows from split partition
20997 */
20999 {
21001 * (NULL for DEFAULT partition) */
21008 /*
21009 * createSplitPartitionContext: create context for partition and fill it
21010 */
21013 {
21019 /*
21020 * Prepare a BulkInsertState for table_tuple_insert. The FSM is empty, so
21021 * don't bother using it.
21022 */
21025 /* Create tuple slot for new partition. */
21031 }
21033 /*
21034 * deleteSplitPartitionContext: delete context for partition
21035 */
21036 static void
21038 {
21045 }
21047 /*
21048 * moveSplitTableRows: scan split partition (splitRel) of partitioned table
21049 * (rel) and move rows into new partitions.
21050 *
21051 * New partitions description:
21052 * partlist: list of pointers to SinglePartitionSpec structures.
21053 * newPartRels: list of Relations.
21054 * defaultPartOid: oid of DEFAULT partition, for table rel.
21055 */
21056 static void
21057 moveSplitTableRows(Relation rel, Relation splitRel, List *partlist, List *newPartRels, Oid defaultPartOid)
21058 {
21059 /* The FSM is empty, so don't bother using it. */
21061 CommandId mycid;
21067 TableScanDesc scan;
21068 Snapshot snapshot;
21069 MemoryContext oldCxt;
21081 {
21087 {
21088 /* We should not create constraint for detached DEFAULT partition. */
21090 }
21091 else
21092 {
21095 /* Build expression execution states for partition check quals. */
21097 partConstraint =
21100 /* Make boolean expression for ExecCheck(). */
21103 /*
21104 * Map the vars in the constraint expression from rel's attnos to
21105 * splitRel's.
21106 */
21113 }
21115 /* Store partition context into list. */
21117 }
21119 /*
21120 * Create partition context for DEFAULT partition. We can insert values
21121 * into this partition in case spaces with values between new partitions.
21122 */
21124 {
21125 /* Indicate that we allocate context for old DEFAULT partition */
21127 defaultPartCtx = createSplitPartitionContext(table_open(defaultPartOid, AccessExclusiveLock));
21128 }
21132 /* Create necessary tuple slot. */
21136 /*
21137 * Map computing for moving attributes of split partition to new partition
21138 * (for first new partition, but other new partitions can use the same
21139 * map).
21140 */
21145 /* Scan through the rows. */
21149 /*
21150 * Switch to per-tuple memory context and reset it for each tuple
21151 * produced, so we don't leak memory.
21152 */
21156 {
21160 /* Extract data from old tuple. */
21165 /* Search partition for current slot srcslot. */
21167 {
21172 {
21175 }
21177 }
21179 {
21180 /* Use DEFAULT partition if it exists. */
21183 else
21188 }
21191 {
21192 /* Need to use map to copy attributes. */
21194 }
21195 else
21196 {
21197 /* Copy attributes directly. */
21208 }
21210 /* Write the tuple out to the new relation. */
21217 }
21234 /* Need to close table and free buffers for DEFAULT partition. */
21236 {
21240 /* Keep the lock until commit. */
21242 }
21243 }
21245 /*
21246 * createPartitionTable: create table for a new partition with given name
21247 * (newPartName) like table (modelRel)
21248 *
21249 * Emulates command: CREATE [TEMP] TABLE <newPartName> (LIKE <modelRel's name>
21250 * INCLUDING ALL EXCLUDING INDEXES EXCLUDING IDENTITY)
21251 *
21252 * Also, this function sets the new partition access method same as parent
21253 * table access methods (similarly to CREATE TABLE ... PARTITION OF). It
21254 * checks that parent and child tables have compatible persistence.
21255 *
21256 * Function returns the created relation (locked in AccessExclusiveLock mode).
21257 */
21258 static Relation
21261 {
21265 Relation newRel;
21267 /* If existing rel is temp, it must belong to this session */
21274 /* New partition should have the same persistence as modelRel */
21292 /*
21293 * Indexes will be inherited on "attach new partitions" stage, after data
21294 * moving.
21295 */
21296 tlc->options = CREATE_TABLE_LIKE_ALL & ~(CREATE_TABLE_LIKE_INDEXES | CREATE_TABLE_LIKE_IDENTITY);
21300 /* Need to make a wrapper PlannedStmt. */
21311 PROCESS_UTILITY_SUBCOMMAND,
21312 NULL,
21313 NULL,
21314 None_Receiver,
21315 NULL);
21317 /*
21318 * Open the new partition with no lock, because we already have
21319 * AccessExclusiveLock placed there after creation.
21320 */
21323 /*
21324 * We intended to create the partition with the same persistence as the
21325 * parent table, but we still need to recheck because that might be
21326 * affected by the search_path. If the parent is permanent, so must be
21327 * all of its partitions.
21328 */
21336 /* Permanent rels cannot be partitions belonging to temporary parent */
21345 }
21347 /*
21348 * ALTER TABLE <name> SPLIT PARTITION <partition-name> INTO <partition-list>
21349 */
21350 static void
21353 {
21354 Relation splitRel;
21355 Oid splitRelOid;
21357 Oid namespaceId;
21363 ObjectAddress object;
21364 Oid defaultPartOid;
21368 /*
21369 * We are going to detach and remove this partition: need to use exclusive
21370 * lock for preventing DML-queries to the partition.
21371 */
21376 /* Check descriptions of new partitions. */
21378 {
21379 Oid existing_relid;
21384 /*
21385 * Look up the namespace in which we are supposed to create the
21386 * partition, check we have permission to create there, lock it
21387 * against concurrent drop, and mark stmt->relation as
21388 * RELPERSISTENCE_TEMP if a temporary namespace is selected.
21389 */
21390 namespaceId =
21393 /*
21394 * This would fail later on anyway if the relation already exists. But
21395 * by catching it here we can emit a nicer error message.
21396 */
21399 /* One new partition can have the same name as split partition. */
21405 }
21407 /* Detach split partition. */
21409 /* Do the final part of detaching. */
21412 /*
21413 * If new partition has the same name as split partition then we should
21414 * rename split partition for reusing name.
21415 */
21417 {
21418 /*
21419 * We must bump the command counter to make the split partition tuple
21420 * visible for renaming.
21421 */
21423 /* Rename partition. */
21427 /*
21428 * We must bump the command counter to make the split partition tuple
21429 * visible after renaming.
21430 */
21432 }
21434 /* Create new partitions (like split partition), without indexes. */
21436 {
21438 Relation newPartRel;
21442 }
21444 /* Copy data from split partition to new partitions. */
21446 /* Keep the lock until commit. */
21449 /* Attach new partitions to partitioned table. */
21451 {
21455 /*
21456 * wqueue = NULL: verification for each cloned constraint is not
21457 * needed.
21458 */
21460 /* Keep the lock until commit. */
21462 }
21464 /* Drop split partition. */
21468 /* Probably DROP_CASCADE is not needed. */
21470 }
21472 /*
21473 * moveMergedTablesRows: scan partitions to be merged (mergingPartitionsList)
21474 * of the partitioned table (rel) and move rows into the new partition
21475 * (newPartRel).
21476 */
21477 static void
21479 Relation newPartRel)
21480 {
21481 CommandId mycid;
21483 /* The FSM is empty, so don't bother using it. */
21491 /* Prepare a BulkInsertState for table_tuple_insert. */
21494 /* Create necessary tuple slot. */
21500 {
21504 TableScanDesc scan;
21505 Snapshot snapshot;
21507 /* Create tuple slot for new partition. */
21511 /*
21512 * Map computing for moving attributes of merged partition to new
21513 * partition.
21514 */
21518 /* Scan through the rows. */
21523 {
21526 /* Extract data from old tuple. */
21530 {
21531 /* Need to use map to copy attributes. */
21533 }
21534 else
21535 {
21536 /* Copy attributes directly. */
21547 }
21549 /* Write the tuple out to the new relation. */
21554 }
21563 }
21569 }
21571 /*
21572 * ALTER TABLE <name> MERGE PARTITIONS <partition-list> INTO <partition-name>
21573 */
21574 static void
21577 {
21578 Relation newPartRel;
21581 Oid defaultPartOid;
21583 /*
21584 * Lock all merged partitions, check them and create list with partitions
21585 * contexts.
21586 */
21588 {
21590 Relation mergingPartition;
21592 /*
21593 * We are going to detach and remove this partition: need to use
21594 * exclusive lock for preventing DML-queries to the partition.
21595 */
21598 /*
21599 * Checking that two partitions have the same name was before, in
21600 * function transformPartitionCmdForMerge().
21601 */
21603 {
21604 /* One new partition can have the same name as merged partition. */
21607 /* Generate temporary name. */
21610 /*
21611 * Rename the existing partition with a temporary name, leaving it
21612 * free for the new partition. We don't need to care about this
21613 * in the future because we're going to eventually drop the
21614 * existing partition anyway.
21615 */
21619 /*
21620 * We must bump the command counter to make the new partition
21621 * tuple visible for rename.
21622 */
21624 }
21626 /* Store a next merging partition into the list. */
21628 mergingPartition);
21629 }
21631 /* Detach all merged partitions. */
21632 defaultPartOid =
21635 {
21638 /* Remove the pg_inherits row first. */
21640 /* Do the final part of detaching. */
21642 }
21644 /* Create table for new partition, use partitioned table as model. */
21647 /* Copy data from merged partitions to new partition. */
21650 /* Drop the current partitions before attaching the new one. */
21652 {
21653 ObjectAddress object;
21656 /* Get relation id before table_close() call. */
21661 /* Keep the lock until commit. */
21665 }
21668 /*
21669 * Attach a new partition to the partitioned table. wqueue = NULL:
21670 * verification for each cloned constraint is not needed.
21671 */
21674 /* Keep the lock until commit. */
21676 }