| blob | d7b88b61dccc0c8f94e2ffc47ec9260f76c996da |
1 /*-------------------------------------------------------------------------
2 *
3 * heap.c
4 * code to create and destroy POSTGRES heap relations
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/catalog/heap.c
12 *
13 *
14 * INTERFACE ROUTINES
15 * heap_create() - Create an uncataloged heap relation
16 * heap_create_with_catalog() - Create a cataloged relation
17 * heap_drop_with_catalog() - Removes named relation from catalogs
18 *
19 * NOTES
20 * this code taken from access/heap/create.c, which contains
21 * the old heap_create_with_catalog, amcreate, and amdestroy.
22 * those routines will soon call these routines using the function
23 * manager,
24 * just like the poorly named "NewXXX" routines do. The
25 * "New" routines are all going to die soon, once and for all!
26 * -cim 1/13/91
27 *
28 *-------------------------------------------------------------------------
29 */
79 /* Potentially set by pg_upgrade_support functions */
86 Relation new_rel_desc,
87 Oid new_rel_oid,
88 Oid new_type_oid,
89 Oid reloftype,
90 Oid relowner,
92 TransactionId relfrozenxid,
93 TransactionId relminmxid,
94 Datum relacl,
95 Datum reloptions);
97 Oid typeNamespace,
98 Oid new_rel_oid,
100 Oid ownerid,
101 Oid new_row_type,
102 Oid new_array_type);
119 /* ----------------------------------------------------------------
120 * XXX UGLY HARD CODED BADNESS FOLLOWS XXX
121 *
122 * these should all be moved to someplace in the lib/catalog
123 * module, if not obliterated first.
124 * ----------------------------------------------------------------
125 */
128 /*
129 * Note:
130 * Should the system special case these attributes in the future?
131 * Advantage: consume much less space in the ATTRIBUTE relation.
132 * Disadvantage: special cases will be all over the place.
133 */
135 /*
136 * The initializers below do not include trailing variable length fields,
137 * but that's OK - we're never going to reference anything beyond the
138 * fixed-size portion of the structure anyway. Fields that can default
139 * to zeroes are also not mentioned.
140 */
154 };
168 };
182 };
196 };
210 };
212 /*
213 * We decided to call this attribute "tableoid" rather than say
214 * "classoid" on the basis that in the future there may be more than one
215 * table of a particular class/type. In any case table is still the word
216 * used in SQL.
217 */
230 };
234 /*
235 * This function returns a Form_pg_attribute pointer for a system attribute.
236 * Note that we elog if the presented attno is invalid, which would only
237 * happen if there's a problem upstream.
238 */
241 {
245 }
247 /*
248 * If the given name is a system attribute name, return a Form_pg_attribute
249 * pointer for a prototype definition. If not, return NULL.
250 */
253 {
257 {
262 }
265 }
268 /* ----------------------------------------------------------------
269 * XXX END OF UGLY HARD CODED BADNESS XXX
270 * ---------------------------------------------------------------- */
273 /* ----------------------------------------------------------------
274 * heap_create - Create an uncataloged heap relation
275 *
276 * Note API change: the caller must now always provide the OID
277 * to use for the relation. The relfilenumber may be (and in
278 * the simplest cases is) left unspecified.
279 *
280 * create_storage indicates whether or not to create the storage.
281 * However, even if create_storage is true, no storage will be
282 * created if the relkind is one that doesn't have storage.
283 *
284 * rel->rd_rel is initialized by RelationBuildLocalRelation,
285 * and is mostly zeroes at return.
286 * ----------------------------------------------------------------
287 */
288 Relation
290 Oid relnamespace,
291 Oid reltablespace,
292 Oid relid,
293 RelFileNumber relfilenumber,
294 Oid accessmtd,
295 TupleDesc tupDesc,
304 {
305 Relation rel;
307 /* The caller must have provided an OID for the relation. */
310 /*
311 * Don't allow creating relations in pg_catalog directly, even though it
312 * is allowed to move user defined relations there. Semantics with search
313 * paths including pg_catalog are too confusing for now.
314 *
315 * But allow creating indexes on relations in pg_catalog even if
316 * allow_system_table_mods = off, upper layers already guarantee it's on a
317 * user defined relation, not a system one.
318 */
332 /*
333 * Force reltablespace to zero if the relation kind does not support
334 * tablespaces. This is mainly just for cleanliness' sake.
335 */
339 /* Don't create storage for relkinds without physical storage. */
342 else
343 {
344 /*
345 * If relfilenumber is unspecified by the caller then create storage
346 * with oid same as relid.
347 */
350 }
352 /*
353 * Never allow a pg_class entry to explicitly specify the database's
354 * default tablespace in reltablespace; force it to zero instead. This
355 * ensures that if the database is cloned with a different default
356 * tablespace, the pg_class entry will still match where CREATE DATABASE
357 * will put the physically copied relation.
358 *
359 * Yes, this is a bit of a hack.
360 */
364 /*
365 * build the relcache entry.
366 */
368 relnamespace,
369 tupDesc,
370 relid,
371 accessmtd,
372 relfilenumber,
373 reltablespace,
374 shared_relation,
375 mapped_relation,
376 relpersistence,
377 relkind);
379 /*
380 * Have the storage manager create the relation's disk file, if needed.
381 *
382 * For tables, the AM callback creates both the main and the init fork.
383 * For others, only the main fork is created; the other forks will be
384 * created on demand.
385 */
387 {
390 relpersistence,
394 else
396 }
398 /*
399 * If a tablespace is specified, removal of that tablespace is normally
400 * protected by the existence of a physical file; but for relations with
401 * no files, add a pg_shdepend entry to account for that.
402 */
405 reltablespace);
407 /* ensure that stats are dropped if transaction aborts */
411 }
413 /* ----------------------------------------------------------------
414 * heap_create_with_catalog - Create a cataloged relation
415 *
416 * this is done in multiple steps:
417 *
418 * 1) CheckAttributeNamesTypes() is used to make certain the tuple
419 * descriptor contains a valid set of attribute names and types
420 *
421 * 2) pg_class is opened and get_relname_relid()
422 * performs a scan to ensure that no relation with the
423 * same name already exists.
424 *
425 * 3) heap_create() is called to create the new relation on disk.
426 *
427 * 4) TypeCreate() is called to define a new type corresponding
428 * to the new relation.
429 *
430 * 5) AddNewRelationTuple() is called to register the
431 * relation in pg_class.
432 *
433 * 6) AddNewAttributeTuples() is called to register the
434 * new relation's schema in pg_attribute.
435 *
436 * 7) StoreConstraints is called () - vadim 08/22/97
437 *
438 * 8) the relations are closed and the new relation's oid
439 * is returned.
440 *
441 * ----------------------------------------------------------------
442 */
444 /* --------------------------------
445 * CheckAttributeNamesTypes
446 *
447 * this is used to make certain the tuple descriptor contains a
448 * valid set of attribute names and datatypes. a problem simply
449 * generates ereport(ERROR) which aborts the current transaction.
450 *
451 * relkind is the relkind of the relation to be created.
452 * flags controls which datatypes are allowed, cf CheckAttributeType.
453 * --------------------------------
454 */
455 void
458 {
463 /* Sanity check on column count */
468 MaxHeapAttributeNumber)));
470 /*
471 * first check for collision with system attribute names
472 *
473 * Skip this for a view or type relation, since those don't have system
474 * attributes.
475 */
477 {
479 {
487 }
488 }
490 /*
491 * next check for repeated attribute names
492 */
494 {
496 {
503 }
504 }
506 /*
507 * next check the attribute types
508 */
510 {
515 flags);
516 }
517 }
519 /* --------------------------------
520 * CheckAttributeType
521 *
522 * Verify that the proposed datatype of an attribute is legal.
523 * This is needed mainly because there are types (and pseudo-types)
524 * in the catalogs that we do not support as elements of real tuples.
525 * We also check some other properties required of a table column.
526 *
527 * If the attribute is being proposed for addition to an existing table or
528 * composite type, pass a one-element list of the rowtype OID as
529 * containing_rowtypes. When checking a to-be-created rowtype, it's
530 * sufficient to pass NIL, because there could not be any recursive reference
531 * to a not-yet-existing rowtype.
532 *
533 * flags is a bitmask controlling which datatypes we allow. For the most
534 * part, pseudo-types are disallowed as attribute types, but there are some
535 * exceptions: ANYARRAYOID, RECORDOID, and RECORDARRAYOID can be allowed
536 * in some cases. (This works because values of those type classes are
537 * self-identifying to some extent. However, RECORDOID and RECORDARRAYOID
538 * are reliably identifiable only within a session, since the identity info
539 * may use a typmod that is only locally assigned. The caller is expected
540 * to know whether these cases are safe.)
541 *
542 * flags can also control the phrasing of the error messages. If
543 * CHKATYPE_IS_PARTKEY is specified, "attname" should be a partition key
544 * column number as text, not a real column name.
545 * --------------------------------
546 */
547 void
552 {
554 Oid att_typelem;
556 /* since this function recurses, it could be driven to stack overflow */
560 {
561 /*
562 * We disallow pseudo-type columns, with the exception of ANYARRAY,
563 * RECORD, and RECORD[] when the caller says that those are OK.
564 *
565 * We don't need to worry about recursive containment for RECORD and
566 * RECORD[] because (a) no named composite type should be allowed to
567 * contain those, and (b) two "anonymous" record types couldn't be
568 * considered to be the same type, so infinite recursion isn't
569 * possible.
570 */
574 {
578 /* translator: first %s is an integer not a name */
581 else
586 }
587 }
589 {
590 /*
591 * If it's a domain, recurse to check its base type.
592 */
594 containing_rowtypes,
595 flags);
596 }
598 {
599 /*
600 * For a composite type, recurse into its attributes.
601 */
602 Relation relation;
603 TupleDesc tupdesc;
606 /*
607 * Check for self-containment. Eventually we might be able to allow
608 * this (just return without complaint, if so) but it's not clear how
609 * many other places would require anti-recursion defenses before it
610 * would be safe to allow tables to contain their own rowtype.
611 */
625 {
632 containing_rowtypes,
634 }
639 }
641 {
642 /*
643 * If it's a range, recurse to check its subtype.
644 */
647 containing_rowtypes,
648 flags);
649 }
651 {
652 /*
653 * Must recurse into array types, too, in case they are composite.
654 */
656 containing_rowtypes,
657 flags);
658 }
660 /*
661 * This might not be strictly invalid per SQL standard, but it is pretty
662 * useless, and it cannot be dumped, so we must disallow it.
663 */
665 {
669 /* translator: first %s is an integer not a name */
673 else
679 }
680 }
682 /*
683 * InsertPgAttributeTuples
684 * Construct and insert a set of tuples in pg_attribute.
685 *
686 * Caller has already opened and locked pg_attribute. tupdesc contains the
687 * attributes to insert. attcacheoff is always initialized to -1.
688 * tupdesc_extra supplies the values for certain variable-length/nullable
689 * pg_attribute fields and must contain the same number of elements as tupdesc
690 * or be NULL. The other variable-length fields of pg_attribute are always
691 * initialized to null values.
692 *
693 * indstate is the index state for CatalogTupleInsertWithInfo. It can be
694 * passed as NULL, in which case we'll fetch the necessary info. (Don't do
695 * this when inserting multiple attributes, because it's a tad more
696 * expensive.)
697 *
698 * new_rel_oid is the relation OID assigned to the attributes inserted.
699 * If set to InvalidOid, the relation OID from tupdesc is used instead.
700 */
701 void
703 TupleDesc tupdesc,
704 Oid new_rel_oid,
706 CatalogIndexState indstate)
707 {
709 TupleDesc td;
717 /* Initialize the number of slots to use */
725 {
736 else
737 slot[slotCount]->tts_values[Anum_pg_attribute_attrelid - 1] = ObjectIdGetDatum(attrs->attrelid);
740 slot[slotCount]->tts_values[Anum_pg_attribute_atttypid - 1] = ObjectIdGetDatum(attrs->atttypid);
748 slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);
749 slot[slotCount]->tts_values[Anum_pg_attribute_attcompression - 1] = CharGetDatum(attrs->attcompression);
750 slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);
752 slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);
753 slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);
754 slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);
755 slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);
756 slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);
757 slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int16GetDatum(attrs->attinhcount);
758 slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);
760 {
761 slot[slotCount]->tts_values[Anum_pg_attribute_attstattarget - 1] = attrs_extra->attstattarget.value;
762 slot[slotCount]->tts_isnull[Anum_pg_attribute_attstattarget - 1] = attrs_extra->attstattarget.isnull;
766 }
767 else
768 {
771 }
773 /*
774 * The remaining fields are not set for new columns.
775 */
781 slotCount++;
783 /*
784 * If slots are full or the end of processing has been reached, insert
785 * a batch of tuples.
786 */
788 {
789 /* fetch index info only when we know we need it */
791 {
794 }
796 /* insert the new tuples and update the indexes */
798 indstate);
800 }
802 natts++;
803 }
810 }
812 /* --------------------------------
813 * AddNewAttributeTuples
814 *
815 * this registers the new relation's schema by adding
816 * tuples to pg_attribute.
817 * --------------------------------
818 */
819 static void
821 TupleDesc tupdesc,
823 {
824 Relation rel;
825 CatalogIndexState indstate;
827 ObjectAddress myself,
828 referenced;
830 /*
831 * open pg_attribute and its indexes.
832 */
839 /* add dependencies on their datatypes and collations */
841 {
844 /* Add dependency info */
849 /* The default collation is pinned, so don't bother recording it */
852 {
856 }
857 }
859 /*
860 * Next we add the system attributes. Skip all for a view or type
861 * relation. We don't bother with making datatype dependencies here,
862 * since presumably all these types are pinned.
863 */
865 {
866 TupleDesc td;
872 }
874 /*
875 * clean up
876 */
880 }
882 /* --------------------------------
883 * InsertPgClassTuple
884 *
885 * Construct and insert a new tuple in pg_class.
886 *
887 * Caller has already opened and locked pg_class.
888 * Tuple data is taken from new_rel_desc->rd_rel, except for the
889 * variable-width fields which are not present in a cached reldesc.
890 * relacl and reloptions are passed in Datum form (to avoid having
891 * to reference the data types in heap.h). Pass (Datum) 0 to set them
892 * to NULL.
893 * --------------------------------
894 */
895 void
897 Relation new_rel_desc,
898 Oid new_rel_oid,
899 Datum relacl,
900 Datum reloptions)
901 {
905 HeapTuple tup;
907 /* This is a tad tedious, but way cleaner than what we used to do... */
943 else
947 else
950 /* relpartbound is set by updating this tuple, if necessary */
955 /* finally insert the new tuple, update the indexes, and clean up */
959 }
961 /* --------------------------------
962 * AddNewRelationTuple
963 *
964 * this registers the new relation in the catalogs by
965 * adding a tuple to pg_class.
966 * --------------------------------
967 */
968 static void
970 Relation new_rel_desc,
971 Oid new_rel_oid,
972 Oid new_type_oid,
973 Oid reloftype,
974 Oid relowner,
976 TransactionId relfrozenxid,
977 TransactionId relminmxid,
978 Datum relacl,
979 Datum reloptions)
980 {
981 Form_pg_class new_rel_reltup;
983 /*
984 * first we update some of the information in our uncataloged relation's
985 * relation descriptor.
986 */
989 /* The relation is empty */
994 /* Sequences always have a known size */
996 {
999 }
1007 /* relispartition is always set by updating this tuple later */
1010 /* fill rd_att's type ID with something sane even if reltype is zero */
1014 /* Now build and insert the tuple */
1017 }
1020 /* --------------------------------
1021 * AddNewRelationType -
1022 *
1023 * define a composite type corresponding to the new relation
1024 * --------------------------------
1025 */
1026 static ObjectAddress
1028 Oid typeNamespace,
1029 Oid new_rel_oid,
1031 Oid ownerid,
1032 Oid new_row_type,
1033 Oid new_array_type)
1034 {
1035 return
1068 }
1070 /* --------------------------------
1071 * heap_create_with_catalog
1072 *
1073 * creates a new cataloged relation. see comments above.
1074 *
1075 * Arguments:
1076 * relname: name to give to new rel
1077 * relnamespace: OID of namespace it goes in
1078 * reltablespace: OID of tablespace it goes in
1079 * relid: OID to assign to new rel, or InvalidOid to select a new OID
1080 * reltypeid: OID to assign to rel's rowtype, or InvalidOid to select one
1081 * reloftypeid: if a typed table, OID of underlying type; else InvalidOid
1082 * ownerid: OID of new rel's owner
1083 * accessmtd: OID of new rel's access method
1084 * tupdesc: tuple descriptor (source of column definitions)
1085 * cooked_constraints: list of precooked check constraints and defaults
1086 * relkind: relkind for new rel
1087 * relpersistence: rel's persistence status (permanent, temp, or unlogged)
1088 * shared_relation: true if it's to be a shared relation
1089 * mapped_relation: true if the relation will use the relfilenumber map
1090 * oncommit: ON COMMIT marking (only relevant if it's a temp table)
1091 * reloptions: reloptions in Datum form, or (Datum) 0 if none
1092 * use_user_acl: true if should look for user-defined default permissions;
1093 * if false, relacl is always set NULL
1094 * allow_system_table_mods: true to allow creation in system namespaces
1095 * is_internal: is this a system-generated catalog?
1096 *
1097 * Output parameters:
1098 * typaddress: if not null, gets the object address of the new pg_type entry
1099 * (this must be null if the relkind is one that doesn't get a pg_type entry)
1100 *
1101 * Returns the OID of the new relation
1102 * --------------------------------
1103 */
1104 Oid
1106 Oid relnamespace,
1107 Oid reltablespace,
1108 Oid relid,
1109 Oid reltypeid,
1110 Oid reloftypeid,
1111 Oid ownerid,
1112 Oid accessmtd,
1113 TupleDesc tupdesc,
1119 OnCommitAction oncommit,
1120 Datum reloptions,
1124 Oid relrewrite,
1126 {
1127 Relation pg_class_desc;
1128 Relation new_rel_desc;
1130 Oid existing_relid;
1131 Oid old_type_oid;
1132 Oid new_type_oid;
1134 /* By default set to InvalidOid unless overridden by binary-upgrade */
1136 TransactionId relfrozenxid;
1137 MultiXactId relminmxid;
1141 /*
1142 * sanity checks
1143 */
1146 /*
1147 * Validate proposed tupdesc for the desired relkind. If
1148 * allow_system_table_mods is on, allow ANYARRAY to be used; this is a
1149 * hack to allow creating pg_statistic and cloning it during VACUUM FULL.
1150 */
1154 /*
1155 * This would fail later on anyway, if the relation already exists. But
1156 * by catching it here we can emit a nicer error message.
1157 */
1164 /*
1165 * Since we are going to create a rowtype as well, also check for
1166 * collision with an existing type name. If there is one and it's an
1167 * autogenerated array, we can rename it out of the way; otherwise we can
1168 * at least give a good error message.
1169 */
1174 {
1180 "so you must use a name that doesn't conflict "
1182 }
1184 /*
1185 * Shared relations must be in pg_global (last-ditch check)
1186 */
1190 /*
1191 * Allocate an OID for the relation, unless we were told what to use.
1192 *
1193 * The OID will be the relfilenumber as well, so make sure it doesn't
1194 * collide with either pg_class OIDs or existing physical files.
1195 */
1197 {
1198 /* Use binary-upgrade override for pg_class.oid and relfilenumber */
1200 {
1201 /*
1202 * Indexes are not supported here; they use
1203 * binary_upgrade_next_index_pg_class_oid.
1204 */
1209 {
1210 /* There might be no TOAST table, so we have to test for it. */
1212 {
1223 }
1224 }
1225 else
1226 {
1236 {
1244 }
1245 }
1246 }
1250 relpersistence);
1251 }
1253 /*
1254 * Other sessions' catalog scans can't find this until we commit. Hence,
1255 * it doesn't hurt to hold AccessExclusiveLock. Do it here so callers
1256 * can't accidentally vary in their lock mode or acquisition timing.
1257 */
1260 /*
1261 * Determine the relation's initial permissions.
1262 */
1264 {
1266 {
1273 relnamespace);
1277 relnamespace);
1282 }
1283 }
1284 else
1287 /*
1288 * Create the relcache entry (mostly dummy at this point) and the physical
1289 * disk file. (If we fail further down, it's the smgr's responsibility to
1290 * remove the disk file again.)
1291 *
1292 * NB: Note that passing create_storage = true is correct even for binary
1293 * upgrade. The storage we create here will be replaced later, but we
1294 * need to have something on disk in the meanwhile.
1295 */
1297 relnamespace,
1298 reltablespace,
1299 relid,
1300 relfilenumber,
1301 accessmtd,
1302 tupdesc,
1303 relkind,
1304 relpersistence,
1305 shared_relation,
1306 mapped_relation,
1307 allow_system_table_mods,
1316 /*
1317 * Decide whether to create a pg_type entry for the relation's rowtype.
1318 * These types are made except where the use of a relation as such is an
1319 * implementation detail: toast tables, sequences and indexes.
1320 */
1325 {
1326 Oid new_array_oid;
1327 ObjectAddress new_type_addr;
1330 /*
1331 * We'll make an array over the composite type, too. For largely
1332 * historical reasons, the array type's OID is assigned first.
1333 */
1336 /*
1337 * Make the pg_type entry for the composite type. The OID of the
1338 * composite type can be preselected by the caller, but if reltypeid
1339 * is InvalidOid, we'll generate a new OID for it.
1340 *
1341 * NOTE: we could get a unique-index failure here, in case someone
1342 * else is creating the same type name in parallel but hadn't
1343 * committed yet when we checked for a duplicate name above.
1344 */
1346 relnamespace,
1347 relid,
1348 relkind,
1349 ownerid,
1350 reltypeid,
1351 new_array_oid);
1356 /* Now create the array type. */
1393 }
1394 else
1395 {
1396 /* Caller should not be expecting a type to be created. */
1401 }
1403 /*
1404 * now create an entry in pg_class for the relation.
1405 *
1406 * NOTE: we could get a unique-index failure here, in case someone else is
1407 * creating the same relation name in parallel but hadn't committed yet
1408 * when we checked for a duplicate name above.
1409 */
1411 new_rel_desc,
1412 relid,
1413 new_type_oid,
1414 reloftypeid,
1415 ownerid,
1416 relkind,
1417 relfrozenxid,
1418 relminmxid,
1420 reloptions);
1422 /*
1423 * now add tuples to pg_attribute for the attributes in our new relation.
1424 */
1427 /*
1428 * Make a dependency link to force the relation to be deleted if its
1429 * namespace is. Also make a dependency link to its owner, as well as
1430 * dependencies for any roles mentioned in the default ACL.
1431 *
1432 * For composite types, these dependencies are tracked for the pg_type
1433 * entry, so we needn't record them here. Likewise, TOAST tables don't
1434 * need a namespace dependency (they live in a pinned namespace) nor an
1435 * owner dependency (they depend indirectly through the parent table), nor
1436 * should they have any ACL entries. The same applies for extension
1437 * dependencies.
1438 *
1439 * Also, skip this in bootstrap mode, since we don't make dependencies
1440 * while bootstrapping.
1441 */
1445 {
1446 ObjectAddress myself,
1447 referenced;
1464 {
1467 }
1469 /*
1470 * Make a dependency link to force the relation to be deleted if its
1471 * access method is.
1472 *
1473 * No need to add an explicit dependency for the toast table, as the
1474 * main table depends on it. Partitioned tables may not have an
1475 * access method set.
1476 */
1479 {
1482 }
1486 }
1488 /* Post creation hook for new relation */
1491 /*
1492 * Store any supplied constraints and defaults.
1493 *
1494 * NB: this may do a CommandCounterIncrement and rebuild the relcache
1495 * entry, so the relation must be valid and self-consistent at this point.
1496 * In particular, there are not yet constraints and defaults anywhere.
1497 */
1500 /*
1501 * If there's a special on-commit action, remember it
1502 */
1506 /*
1507 * ok, the relation has been cataloged, so close our relations and return
1508 * the OID of the newly created relation.
1509 */
1514 }
1516 /*
1517 * RelationRemoveInheritance
1518 *
1519 * Formerly, this routine checked for child relations and aborted the
1520 * deletion if any were found. Now we rely on the dependency mechanism
1521 * to check for or delete child relations. By the time we get here,
1522 * there are no children and we need only remove any pg_inherits rows
1523 * linking this relation to its parent(s).
1524 */
1525 static void
1527 {
1528 Relation catalogRelation;
1529 SysScanDesc scan;
1530 ScanKeyData key;
1531 HeapTuple tuple;
1536 Anum_pg_inherits_inhrelid,
1548 }
1550 /*
1551 * DeleteRelationTuple
1552 *
1553 * Remove pg_class row for the given relid.
1554 *
1555 * Note: this is shared by relation deletion and index deletion. It's
1556 * not intended for use anyplace else.
1557 */
1558 void
1560 {
1561 Relation pg_class_desc;
1562 HeapTuple tup;
1564 /* Grab an appropriate lock on the pg_class relation */
1571 /* delete the relation tuple from pg_class, and finish up */
1577 }
1579 /*
1580 * DeleteAttributeTuples
1581 *
1582 * Remove pg_attribute rows for the given relid.
1583 *
1584 * Note: this is shared by relation deletion and index deletion. It's
1585 * not intended for use anyplace else.
1586 */
1587 void
1589 {
1590 Relation attrel;
1591 SysScanDesc scan;
1593 HeapTuple atttup;
1595 /* Grab an appropriate lock on the pg_attribute relation */
1598 /* Use the index to scan only attributes of the target relation */
1600 Anum_pg_attribute_attrelid,
1607 /* Delete all the matching tuples */
1611 /* Clean up after the scan */
1614 }
1616 /*
1617 * DeleteSystemAttributeTuples
1618 *
1619 * Remove pg_attribute rows for system columns of the given relid.
1620 *
1621 * Note: this is only used when converting a table to a view. Views don't
1622 * have system columns, so we should remove them from pg_attribute.
1623 */
1624 void
1626 {
1627 Relation attrel;
1628 SysScanDesc scan;
1630 HeapTuple atttup;
1632 /* Grab an appropriate lock on the pg_attribute relation */
1635 /* Use the index to scan only system attributes of the target relation */
1637 Anum_pg_attribute_attrelid,
1641 Anum_pg_attribute_attnum,
1648 /* Delete all the matching tuples */
1652 /* Clean up after the scan */
1655 }
1657 /*
1658 * RemoveAttributeById
1659 *
1660 * This is the guts of ALTER TABLE DROP COLUMN: actually mark the attribute
1661 * deleted in pg_attribute. We also remove pg_statistic entries for it.
1662 * (Everything else needed, such as getting rid of any pg_attrdef entry,
1663 * is handled by dependency.c.)
1664 */
1665 void
1667 {
1668 Relation rel;
1669 Relation attr_rel;
1670 HeapTuple tuple;
1671 Form_pg_attribute attStruct;
1677 /*
1678 * Grab an exclusive lock on the target table, which we will NOT release
1679 * until end of transaction. (In the simple case where we are directly
1680 * dropping this column, ATExecDropColumn already did this ... but when
1681 * cascading from a drop of some other object, we may not have any lock.)
1682 */
1695 /* Mark the attribute as dropped */
1698 /*
1699 * Set the type OID to invalid. A dropped attribute's type link cannot be
1700 * relied on (once the attribute is dropped, the type might be too).
1701 * Fortunately we do not need the type row --- the only really essential
1702 * information is the type's typlen and typalign, which are preserved in
1703 * the attribute's attlen and attalign. We set atttypid to zero here as a
1704 * means of catching code that incorrectly expects it to be valid.
1705 */
1708 /* Remove any not-null constraint the column may have */
1711 /* Unset this so no one tries to look up the generation expression */
1714 /*
1715 * Change the column name to something that isn't likely to conflict
1716 */
1721 /* Clear the missing value */
1726 /*
1727 * Clear the other nullable fields. This saves some space in pg_attribute
1728 * and removes no longer useful information.
1729 */
1744 /*
1745 * Because updating the pg_attribute row will trigger a relcache flush for
1746 * the target relation, we need not do anything else to notify other
1747 * backends of the change.
1748 */
1755 }
1757 /*
1758 * heap_drop_with_catalog - removes specified relation from catalogs
1759 *
1760 * Note that this routine is not responsible for dropping objects that are
1761 * linked to the pg_class entry via dependencies (for example, indexes and
1762 * constraints). Those are deleted by the dependency-tracing logic in
1763 * dependency.c before control gets here. In general, therefore, this routine
1764 * should never be called directly; go through performDeletion() instead.
1765 */
1766 void
1768 {
1769 Relation rel;
1770 HeapTuple tuple;
1774 /*
1775 * To drop a partition safely, we must grab exclusive lock on its parent,
1776 * because another backend might be about to execute a query on the parent
1777 * table. If it relies on previously cached partition descriptor, then it
1778 * could attempt to access the just-dropped relation as its partition. We
1779 * must therefore take a table lock strong enough to prevent all queries
1780 * on the table from proceeding until we commit and send out a
1781 * shared-cache-inval notice that will make them update their partition
1782 * descriptors.
1783 */
1788 {
1789 /*
1790 * We have to lock the parent if the partition is being detached,
1791 * because it's possible that some query still has a partition
1792 * descriptor that includes this partition.
1793 */
1797 /*
1798 * If this is not the default partition, dropping it will change the
1799 * default partition's partition constraint, so we must lock it.
1800 */
1804 }
1808 /*
1809 * Open and lock the relation.
1810 */
1813 /*
1814 * There can no longer be anyone *else* touching the relation, but we
1815 * might still have open queries or cursors, or pending trigger events, in
1816 * our own session.
1817 */
1820 /*
1821 * This effectively deletes all rows in the table, and may be done in a
1822 * serializable transaction. In that case we must record a rw-conflict in
1823 * to this transaction from each transaction holding a predicate lock on
1824 * the table.
1825 */
1828 /*
1829 * Delete pg_foreign_table tuple first.
1830 */
1832 {
1833 Relation ftrel;
1834 HeapTuple fttuple;
1846 }
1848 /*
1849 * If a partitioned table, delete the pg_partitioned_table tuple.
1850 */
1854 /*
1855 * If the relation being dropped is the default partition itself,
1856 * invalidate its entry in pg_partitioned_table.
1857 */
1861 /*
1862 * Schedule unlinking of the relation's physical files at commit.
1863 */
1867 /* ensure that stats are dropped if transaction commits */
1870 /*
1871 * Close relcache entry, but *keep* AccessExclusiveLock on the relation
1872 * until transaction commit. This ensures no one else will try to do
1873 * something with the doomed relation.
1874 */
1877 /*
1878 * Remove any associated relation synchronization states.
1879 */
1882 /*
1883 * Forget any ON COMMIT action for the rel
1884 */
1887 /*
1888 * Flush the relation from the relcache. We want to do this before
1889 * starting to remove catalog entries, just to be certain that no relcache
1890 * entry rebuild will happen partway through. (That should not really
1891 * matter, since we don't do CommandCounterIncrement here, but let's be
1892 * safe.)
1893 */
1896 /*
1897 * remove inheritance information
1898 */
1901 /*
1902 * delete statistics
1903 */
1906 /*
1907 * delete attribute tuples
1908 */
1911 /*
1912 * delete relation tuple
1913 */
1917 {
1918 /*
1919 * If this is not the default partition, the partition constraint of
1920 * the default partition has changed to include the portion of the key
1921 * space previously covered by the dropped partition.
1922 */
1926 /*
1927 * Invalidate the parent's relcache so that the partition is no longer
1928 * included in its partition descriptor.
1929 */
1931 /* keep the lock */
1932 }
1933 }
1936 /*
1937 * RelationClearMissing
1938 *
1939 * Set atthasmissing and attmissingval to false/null for all attributes
1940 * where they are currently set. This can be safely and usefully done if
1941 * the table is rewritten (e.g. by VACUUM FULL or CLUSTER) where we know there
1942 * are no rows left with less than a full complement of attributes.
1943 *
1944 * The caller must have an AccessExclusive lock on the relation.
1945 */
1946 void
1948 {
1949 Relation attr_rel;
1956 Form_pg_attribute attrtuple;
1957 HeapTuple tuple,
1958 newtuple;
1971 /* Get a lock on pg_attribute */
1974 /* process each non-system attribute, including any dropped columns */
1976 {
1986 /* ignore any where atthasmissing is not true */
1988 {
1995 }
1998 }
2000 /*
2001 * Our update of the pg_attribute rows will force a relcache rebuild, so
2002 * there's nothing else to do here.
2003 */
2005 }
2007 /*
2008 * SetAttrMissing
2009 *
2010 * Set the missing value of a single attribute. This should only be used by
2011 * binary upgrade. Takes an AccessExclusive lock on the relation owning the
2012 * attribute.
2013 */
2014 void
2016 {
2020 Datum missingval;
2021 Form_pg_attribute attStruct;
2022 Relation attrrel,
2023 tablerel;
2024 HeapTuple atttup,
2025 newtup;
2027 /* lock the table the attribute belongs to */
2030 /* Don't do anything unless it's a plain table */
2032 {
2035 }
2037 /* Lock the attribute row and get the data */
2045 /* get an array value from the value string */
2051 /* update the tuple - set atthasmissing and attmissingval */
2061 /* clean up */
2065 }
2067 /*
2068 * Store a check-constraint expression for the given relation.
2069 *
2070 * Caller is responsible for updating the count of constraints
2071 * in the pg_class entry for the relation.
2072 *
2073 * The OID of the new constraint is returned.
2074 */
2075 static Oid
2079 {
2084 Oid constrOid;
2086 /*
2087 * Flatten expression to string form for storage.
2088 */
2091 /*
2092 * Find columns of rel that are used in expr
2093 *
2094 * NB: pull_var_clause is okay here only because we don't allow subselects
2095 * in check constraints; it would fail to examine the contents of
2096 * subselects.
2097 */
2102 {
2108 {
2117 }
2119 }
2120 else
2123 /*
2124 * Partitioned tables do not contain any rows themselves, so a NO INHERIT
2125 * constraint makes no sense.
2126 */
2134 /*
2135 * Create the Check Constraint
2136 */
2137 constrOid =
2143 is_validated,
2152 NULL,
2153 NULL,
2154 NULL,
2155 NULL,
2159 NULL,
2174 }
2176 /*
2177 * Store a not-null constraint for the given relation
2178 *
2179 * The OID of the new constraint is returned.
2180 */
2181 static Oid
2185 {
2186 Oid constrOid;
2190 constrOid =
2193 CONSTRAINT_NOTNULL,
2196 is_validated,
2197 InvalidOid,
2205 NULL,
2206 NULL,
2207 NULL,
2208 NULL,
2212 NULL,
2216 NULL,
2217 NULL,
2218 is_local,
2219 inhcount,
2220 is_no_inherit,
2224 }
2226 /*
2227 * Store defaults and constraints (passed as a list of CookedConstraint).
2228 *
2229 * Each CookedConstraint struct is modified to store the new catalog tuple OID.
2230 *
2231 * NOTE: only pre-cooked expressions will be passed this way, which is to
2232 * say expressions inherited from an existing relation. Newly parsed
2233 * expressions can be added later, by direct calls to StoreAttrDefault
2234 * and StoreRelCheck (see AddRelationNewConstraints()).
2235 */
2236 static void
2238 {
2245 /*
2246 * Deparsing of constraint expressions will fail unless the just-created
2247 * pg_attribute tuples for this relation are made visible. So, bump the
2248 * command counter. CAUTION: this will cause a relcache entry rebuild.
2249 */
2253 {
2257 {
2267 is_internal);
2268 numchecks++;
2281 }
2282 }
2286 }
2288 /*
2289 * AddRelationNewConstraints
2290 *
2291 * Add new column default expressions and/or constraint check expressions
2292 * to an existing relation. This is defined to do both for efficiency in
2293 * DefineRelation, but of course you can do just one or the other by passing
2294 * empty lists.
2295 *
2296 * rel: relation to be modified
2297 * newColDefaults: list of RawColumnDefault structures
2298 * newConstraints: list of Constraint nodes
2299 * allow_merge: true if check constraints may be merged with existing ones
2300 * is_local: true if definition is local, false if it's inherited
2301 * is_internal: true if result of some internal process, not a user request
2302 * queryString: used during expression transformation of default values and
2303 * cooked CHECK constraints
2304 *
2305 * All entries in newColDefaults will be processed. Entries in newConstraints
2306 * will be processed only if they are CONSTR_CHECK or CONSTR_NOTNULL types.
2307 *
2308 * Returns a list of CookedConstraint nodes that shows the cooked form of
2309 * the default and constraint expressions added to the relation.
2310 *
2311 * NB: caller should have opened rel with some self-conflicting lock mode,
2312 * and should hold that lock till end of transaction; for normal cases that'll
2313 * be AccessExclusiveLock, but if caller knows that the constraint is already
2314 * enforced by some other means, it can be ShareUpdateExclusiveLock. Also, we
2315 * assume the caller has done a CommandCounterIncrement if necessary to make
2316 * the relation's catalog tuples visible.
2317 */
2318 List *
2326 {
2328 TupleDesc tupleDesc;
2339 /*
2340 * Get info about existing constraints.
2341 */
2346 else
2349 /*
2350 * Create a dummy ParseState and insert the target relation as its sole
2351 * rangetable entry. We need a ParseState for transformExpr.
2352 */
2356 rel,
2357 AccessShareLock,
2358 NULL,
2363 /*
2364 * Process column default expressions.
2365 */
2367 {
2369 Oid defOid;
2376 /*
2377 * If the expression is just a NULL constant, we do not bother to make
2378 * an explicit pg_attrdef entry, since the default behavior is
2379 * equivalent. This applies to column defaults, but not for
2380 * generation expressions.
2381 *
2382 * Note a nonobvious property of this test: if the column is of a
2383 * domain type, what we'll get is not a bare null Const but a
2384 * CoerceToDomain expr, so we will not discard the default. This is
2385 * critical because the column default needs to be retained to
2386 * override any default that the domain might have.
2387 */
2394 /* If the DEFAULT is volatile we cannot use a missing value */
2413 }
2415 /*
2416 * Process constraint expressions.
2417 */
2422 {
2423 Oid constrOid;
2426 {
2430 {
2433 /*
2434 * Transform raw parsetree to executable expression, and
2435 * verify it's valid as a CHECK constraint.
2436 */
2439 }
2440 else
2441 {
2444 /*
2445 * Here, we assume the parser will only pass us valid CHECK
2446 * expressions, so we do no particular checking.
2447 */
2449 }
2451 /*
2452 * Check name uniqueness, or generate a name if none was given.
2453 */
2455 {
2457 /* Check against other new constraints */
2458 /* Needed because we don't do CommandCounterIncrement in loop */
2460 {
2465 ccname)));
2466 }
2468 /* save name for future checks */
2471 /*
2472 * Check against pre-existing constraints. If we are allowed
2473 * to merge with an existing constraint, there's no more to do
2474 * here. (We omit the duplicate constraint from the result,
2475 * which is what ATAddCheckNNConstraint wants.)
2476 */
2482 }
2483 else
2484 {
2485 /*
2486 * When generating a name, we want to create "tab_col_check"
2487 * for a column constraint and "tab_check" for a table
2488 * constraint. We no longer have any info about the syntactic
2489 * positioning of the constraint phrase, so we approximate
2490 * this by seeing whether the expression references more than
2491 * one column. (If the user played by the rules, the result
2492 * is the same...)
2493 *
2494 * Note: pull_var_clause() doesn't descend into sublinks, but
2495 * we eliminated those above; and anyway this only needs to be
2496 * an approximate answer.
2497 */
2503 /* eliminate duplicates */
2510 else
2514 colname,
2517 checknames);
2519 /* save name for future checks */
2521 }
2523 /*
2524 * OK, store it.
2525 */
2526 constrOid =
2530 numchecks++;
2543 }
2545 {
2547 AttrNumber colnum;
2551 /* Determine which column to modify */
2564 /*
2565 * If the column already has a not-null constraint, we don't want
2566 * to add another one; just adjust inheritance status as needed.
2567 */
2572 /*
2573 * If a constraint name is specified, check that it isn't already
2574 * used. Otherwise, choose a non-conflicting one ourselves.
2575 */
2577 {
2586 }
2587 else
2592 nnnames);
2595 constrOid =
2598 is_local,
2599 inhcount,
2614 }
2615 }
2617 /*
2618 * Update the count of constraints in the relation's pg_class tuple. We do
2619 * this even if there was no change, in order to ensure that an SI update
2620 * message is sent out for the pg_class tuple, which will force other
2621 * backends to rebuild their relcache entries for the rel. (This is
2622 * critical if we added defaults but not constraints.)
2623 */
2627 }
2629 /*
2630 * Check for a pre-existing check constraint that conflicts with a proposed
2631 * new one, and either adjust its conislocal/coninhcount settings or throw
2632 * error as needed.
2633 *
2634 * Returns true if merged (constraint is a duplicate), or false if it's
2635 * got a so-far-unique name, or throws error if conflict.
2636 *
2637 * XXX See MergeConstraintsIntoExisting too if you change this code.
2638 */
2639 static bool
2644 {
2646 Relation conDesc;
2647 SysScanDesc conscan;
2649 HeapTuple tup;
2651 /* Search for a pg_constraint entry with same name and relation */
2657 Anum_pg_constraint_conrelid,
2661 Anum_pg_constraint_contypid,
2665 Anum_pg_constraint_conname,
2672 /* There can be at most one matching row */
2674 {
2677 /* Found it. Conflicts if not identical check constraint */
2679 {
2680 Datum val;
2684 Anum_pg_constraint_conbin,
2691 }
2693 /*
2694 * If the existing constraint is purely inherited (no local
2695 * definition) then interpret addition of a local constraint as a
2696 * legal merge. This allows ALTER ADD CONSTRAINT on parent and child
2697 * tables to be given in either order with same end state. However if
2698 * the relation is a partition, all inherited constraints are always
2699 * non-local, including those that were merged.
2700 */
2710 /* If the child constraint is "no inherit" then cannot merge */
2717 /*
2718 * Must not change an existing inherited constraint to "no inherit"
2719 * status. That's because inherited constraints should be able to
2720 * propagate to lower-level children.
2721 */
2728 /*
2729 * If the child constraint is "not valid" then cannot merge with a
2730 * valid parent constraint.
2731 */
2738 /* OK to update the tuple */
2741 ccname)));
2746 /*
2747 * In case of partitions, an inherited constraint must be inherited
2748 * only once since it cannot have multiple parents and it is never
2749 * considered local.
2750 */
2752 {
2755 }
2756 else
2757 {
2765 }
2768 {
2771 }
2774 }
2780 }
2782 /*
2783 * Create the not-null constraints when creating a new relation
2784 *
2785 * These come from two sources: the 'constraints' list (of Constraint) is
2786 * specified directly by the user; the 'old_notnulls' list (of
2787 * CookedConstraint) comes from inheritance. We create one constraint
2788 * for each column, giving priority to user-specified ones, and setting
2789 * inhcount according to how many parents cause each column to get a
2790 * not-null constraint. If a user-specified name clashes with another
2791 * user-specified name, an error is raised.
2792 *
2793 * Returns a list of AttrNumber for columns that need to have the attnotnull
2794 * flag set.
2795 */
2796 List *
2799 {
2804 /*
2805 * We track two lists of names: nnnames keeps all the constraint names,
2806 * givennames tracks user-generated names. The distinction is important,
2807 * because we must raise error for user-generated name conflicts, but for
2808 * system-generated name conflicts we just generate another.
2809 */
2813 /*
2814 * First, create all not-null constraints that are directly specified by
2815 * the user. Note that inheritance might have given us another source for
2816 * each, so we must scan the old_notnulls list and increment inhcount for
2817 * each element with identical attnum. We delete from there any element
2818 * that we process.
2819 *
2820 * We don't use foreach() here because we have two nested loops over the
2821 * constraint list, with possible element deletions in the inner one. If
2822 * we used foreach_delete_current() it could only fix up the state of one
2823 * of the loops, so it seems cleaner to use looping over list indexes for
2824 * both loops. Note that any deletion will happen beyond where the outer
2825 * loop is, so its index never needs adjustment.
2826 */
2828 {
2830 AttrNumber attnum;
2852 /*
2853 * A column can only have one not-null constraint, so discard any
2854 * additional ones that appear for columns we already saw; but check
2855 * that the NO INHERIT flags match.
2856 */
2858 {
2864 {
2871 /*
2872 * Preserve constraint name if one is specified, but raise an
2873 * error if conflicting ones are specified.
2874 */
2876 {
2884 }
2886 /* XXX do we need to verify any other fields? */
2888 }
2889 else
2890 restpos++;
2891 }
2893 /*
2894 * Search in the list of inherited constraints for any entries on the
2895 * same column; determine an inheritance count from that. Also, if at
2896 * least one parent has a constraint for this column, then we must not
2897 * accept a user specification for a NO INHERIT one. Any constraint
2898 * from parents that we process here is deleted from the list: we no
2899 * longer need to process it in the loop below.
2900 */
2902 {
2904 {
2905 /*
2906 * If we get a constraint from the parent, having a local NO
2907 * INHERIT one doesn't work.
2908 */
2916 inhcount++;
2918 }
2919 }
2921 /*
2922 * Determine a constraint name, which may have been specified by the
2923 * user, or raise an error if a conflict exists with another
2924 * user-specified name.
2925 */
2927 {
2929 {
2936 }
2940 }
2941 else
2947 nnnames);
2955 }
2957 /*
2958 * If any column remains in the old_notnulls list, we must create a not-
2959 * null constraint marked not-local for that column. Because multiple
2960 * parents could specify a not-null constraint for the same column, we
2961 * must count how many there are and set an appropriate inhcount
2962 * accordingly, deleting elements we've already processed.
2963 *
2964 * We don't use foreach() here because we have two nested loops over the
2965 * constraint list, with possible element deletions in the inner one. If
2966 * we used foreach_delete_current() it could only fix up the state of one
2967 * of the loops, so it seems cleaner to use looping over list indexes for
2968 * both loops. Note that any deletion will happen beyond where the outer
2969 * loop is, so its index never needs adjustment.
2970 */
2972 {
2981 /*
2982 * Preserve the first non-conflicting constraint name we come across.
2983 */
2988 {
2994 {
2998 inhcount++;
3000 }
3001 else
3002 restpos++;
3003 }
3005 /* If we got a name, make sure it isn't one we've already used */
3007 {
3009 {
3011 {
3014 }
3015 }
3016 }
3018 /* and choose a name, if needed */
3025 nnnames);
3028 /* ignore the origin constraint's is_local and inhcount */
3033 }
3036 }
3038 /*
3039 * Update the count of constraints in the relation's pg_class tuple.
3040 *
3041 * Caller had better hold exclusive lock on the relation.
3042 *
3043 * An important side effect is that a SI update message will be sent out for
3044 * the pg_class tuple, which will force other backends to rebuild their
3045 * relcache entries for the rel. Also, this backend will rebuild its
3046 * own relcache entry at the next CommandCounterIncrement.
3047 */
3048 static void
3050 {
3051 Relation relrel;
3052 HeapTuple reltup;
3053 Form_pg_class relStruct;
3064 {
3068 }
3069 else
3070 {
3071 /* Skip the disk update, but force relcache inval anyway */
3073 }
3077 }
3079 /*
3080 * Check for references to generated columns
3081 */
3082 static bool
3084 {
3090 {
3092 Oid relid;
3093 AttrNumber attnum;
3108 /* A whole-row Var is necessarily self-referential, so forbid it */
3115 /* System columns were already checked in the parser */
3118 }
3119 else
3121 context);
3122 }
3124 static void
3126 {
3128 }
3130 /*
3131 * Take a raw default and convert it to a cooked format ready for
3132 * storage.
3133 *
3134 * Parse state should be set up to recognize any vars that might appear
3135 * in the expression. (Even though we plan to reject vars, it's more
3136 * user-friendly to give the correct error message than "unknown var".)
3137 *
3138 * If atttypid is not InvalidOid, coerce the expression to the specified
3139 * type (and typmod atttypmod). attname is only needed in this case:
3140 * it is used in the error message, if any.
3141 */
3142 Node *
3145 Oid atttypid,
3146 int32 atttypmod,
3149 {
3154 /*
3155 * Transform raw parsetree to executable expression.
3156 */
3157 expr = transformExpr(pstate, raw_default, attgenerated ? EXPR_KIND_GENERATED_COLUMN : EXPR_KIND_COLUMN_DEFAULT);
3160 {
3161 /* Disallow refs to other generated columns */
3164 /* Disallow mutable functions */
3169 }
3170 else
3171 {
3172 /*
3173 * For a default expression, transformExpr() should have rejected
3174 * column references.
3175 */
3177 }
3179 /*
3180 * Coerce the expression to the correct type and typmod, if given. This
3181 * should match the parser's processing of non-defaulted expressions ---
3182 * see transformAssignedExpr().
3183 */
3185 {
3190 COERCION_ASSIGNMENT,
3191 COERCE_IMPLICIT_CAST,
3198 attname,
3202 }
3204 /*
3205 * Finally, take care of collations in the finished expression.
3206 */
3210 }
3212 /*
3213 * Take a raw CHECK constraint expression and convert it to a cooked format
3214 * ready for storage.
3215 *
3216 * Parse state must be set up to recognize any vars that might appear
3217 * in the expression.
3218 */
3223 {
3226 /*
3227 * Transform raw parsetree to executable expression.
3228 */
3231 /*
3232 * Make sure it yields a boolean result.
3233 */
3236 /*
3237 * Take care of collations.
3238 */
3241 /*
3242 * Make sure no outside relations are referred to (this is probably dead
3243 * code now that add_missing_from is history).
3244 */
3249 relname)));
3252 }
3254 /*
3255 * CopyStatistics --- copy entries in pg_statistic from one rel to another
3256 */
3257 void
3259 {
3260 HeapTuple tup;
3261 SysScanDesc scan;
3263 Relation statrel;
3268 /* Now search for stat records */
3270 Anum_pg_statistic_starelid,
3278 {
3279 Form_pg_statistic statform;
3281 /* make a modifiable copy */
3285 /* update the copy of the tuple and insert it */
3288 /* fetch index information when we know we need it */
3295 }
3302 }
3304 /*
3305 * RemoveStatistics --- remove entries in pg_statistic for a rel or column
3306 *
3307 * If attnum is zero, remove all entries for rel; else remove only the one(s)
3308 * for that column.
3309 */
3310 void
3312 {
3313 Relation pgstatistic;
3314 SysScanDesc scan;
3317 HeapTuple tuple;
3322 Anum_pg_statistic_starelid,
3328 else
3329 {
3331 Anum_pg_statistic_staattnum,
3335 }
3340 /* we must loop even when attnum != 0, in case of inherited stats */
3347 }
3350 /*
3351 * RelationTruncateIndexes - truncate all indexes associated
3352 * with the heap relation to zero tuples.
3353 *
3354 * The routine will truncate and then reconstruct the indexes on
3355 * the specified relation. Caller must hold exclusive lock on rel.
3356 */
3357 static void
3359 {
3362 /* Ask the relcache to produce a list of the indexes of the rel */
3364 {
3366 Relation currentIndex;
3369 /* Open the index relation; use exclusive lock, just to be sure */
3372 /*
3373 * Fetch info needed for index_build. Since we know there are no
3374 * tuples that actually need indexing, we can use a dummy IndexInfo.
3375 * This is slightly cheaper to build, but the real point is to avoid
3376 * possibly running user-defined code in index expressions or
3377 * predicates. We might be getting invoked during ON COMMIT
3378 * processing, and we don't want to run any such code then.
3379 */
3382 /*
3383 * Now truncate the actual file (and discard buffers).
3384 */
3387 /* Initialize the index and rebuild */
3388 /* Note: we do not need to re-establish pkey setting */
3391 /* We're done with this index */
3393 }
3394 }
3396 /*
3397 * heap_truncate
3398 *
3399 * This routine deletes all data within all the specified relations.
3400 *
3401 * This is not transaction-safe! There is another, transaction-safe
3402 * implementation in commands/tablecmds.c. We now use this only for
3403 * ON COMMIT truncation of temporary tables, where it doesn't matter.
3404 */
3405 void
3407 {
3411 /* Open relations for processing, and grab exclusive access on each */
3413 {
3415 Relation rel;
3419 }
3421 /* Don't allow truncate on tables that are referenced by foreign keys */
3424 /* OK to do it */
3426 {
3429 /* Truncate the relation */
3432 /* Close the relation, but keep exclusive lock on it until commit */
3434 }
3435 }
3437 /*
3438 * heap_truncate_one_rel
3439 *
3440 * This routine deletes all data within the specified relation.
3441 *
3442 * This is not transaction-safe, because the truncation is done immediately
3443 * and cannot be rolled back later. Caller is responsible for having
3444 * checked permissions etc, and must have obtained AccessExclusiveLock.
3445 */
3446 void
3448 {
3449 Oid toastrelid;
3451 /*
3452 * Truncate the relation. Partitioned tables have no storage, so there is
3453 * nothing to do for them here.
3454 */
3458 /* Truncate the underlying relation */
3461 /* If the relation has indexes, truncate the indexes too */
3464 /* If there is a toast table, truncate that too */
3467 {
3472 /* keep the lock... */
3474 }
3475 }
3477 /*
3478 * heap_truncate_check_FKs
3479 * Check for foreign keys referencing a list of relations that
3480 * are to be truncated, and raise error if there are any
3481 *
3482 * We disallow such FKs (except self-referential ones) since the whole point
3483 * of TRUNCATE is to not scan the individual rows to be thrown away.
3484 *
3485 * This is split out so it can be shared by both implementations of truncate.
3486 * Caller should already hold a suitable lock on the relations.
3487 *
3488 * tempTables is only used to select an appropriate error message.
3489 */
3490 void
3492 {
3497 /*
3498 * Build a list of OIDs of the interesting relations.
3499 *
3500 * If a relation has no triggers, then it can neither have FKs nor be
3501 * referenced by a FK from another table, so we can ignore it. For
3502 * partitioned tables, FKs have no triggers, so we must include them
3503 * anyway.
3504 */
3506 {
3512 }
3514 /*
3515 * Fast path: if no relation has triggers, none has FKs either.
3516 */
3520 /*
3521 * Otherwise, must scan pg_constraint. We make one pass with all the
3522 * relations considered; if this finds nothing, then all is well.
3523 */
3528 /*
3529 * Otherwise we repeat the scan once per relation to identify a particular
3530 * pair of relations to complain about. This is pretty slow, but
3531 * performance shouldn't matter much in a failure path. The reason for
3532 * doing things this way is to ensure that the message produced is not
3533 * dependent on chance row locations within pg_constraint.
3534 */
3536 {
3543 {
3547 {
3557 else
3565 relname2)));
3566 }
3567 }
3568 }
3569 }
3571 /*
3572 * heap_truncate_find_FKs
3573 * Find relations having foreign keys referencing any of the given rels
3574 *
3575 * Input and result are both lists of relation OIDs. The result contains
3576 * no duplicates, does *not* include any rels that were already in the input
3577 * list, and is sorted in OID order. (The last property is enforced mainly
3578 * to guarantee consistent behavior in the regression tests; we don't want
3579 * behavior to change depending on chance locations of rows in pg_constraint.)
3580 *
3581 * Note: caller should already have appropriate lock on all rels mentioned
3582 * in relationIds. Since adding or dropping an FK requires exclusive lock
3583 * on both rels, this ensures that the answer will be stable.
3584 */
3585 List *
3587 {
3592 ScanKeyData key;
3593 Relation fkeyRel;
3594 SysScanDesc fkeyScan;
3595 HeapTuple tuple;
3600 /*
3601 * Must scan pg_constraint. Right now, it is a seqscan because there is
3602 * no available index on confrelid.
3603 */
3606 restart:
3614 {
3617 /* Not a foreign key */
3621 /* Not referencing one of our list of tables */
3625 /*
3626 * If this constraint has a parent constraint which we have not seen
3627 * yet, keep track of it for the second loop, below. Tracking parent
3628 * constraints allows us to climb up to the top-level constraint and
3629 * look for all possible relations referencing the partitioned table.
3630 */
3635 /*
3636 * Add referencer to result, unless present in input list. (Don't
3637 * worry about dupes: we'll fix that below).
3638 */
3641 }
3645 /*
3646 * Process each parent constraint we found to add the list of referenced
3647 * relations by them to the oids list. If we do add any new such
3648 * relations, redo the first loop above. Also, if we see that the parent
3649 * constraint in turn has a parent, add that so that we process all
3650 * relations in a single additional pass.
3651 */
3653 {
3657 Anum_pg_constraint_oid,
3666 {
3669 /*
3670 * pg_constraint rows always appear for partitioned hierarchies
3671 * this way: on the each side of the constraint, one row appears
3672 * for each partition that points to the top-most table on the
3673 * other side.
3674 *
3675 * Because of this arrangement, we can correctly catch all
3676 * relevant relations by adding to 'parent_cons' all rows with
3677 * valid conparentid, and to the 'oids' list all rows with a zero
3678 * conparentid. If any oids are added to 'oids', redo the first
3679 * loop above by setting 'restart'.
3680 */
3685 {
3688 }
3689 }
3692 }
3701 /* Now sort and de-duplicate the result list */
3706 }
3708 /*
3709 * StorePartitionKey
3710 * Store information about the partition key rel into the catalog
3711 */
3712 void
3715 int16 partnatts,
3720 {
3725 Datum partexprDatum;
3726 Relation pg_partitioned_table;
3727 HeapTuple tuple;
3730 ObjectAddress myself;
3731 ObjectAddress referenced;
3736 /* Copy the partition attribute numbers, opclass OIDs into arrays */
3741 /* Convert the expressions (if any) to a text datum */
3743 {
3749 }
3750 else
3755 /* Only this can ever be NULL */
3773 /* Mark this relation as dependent on a few things as follows */
3777 /* Operator class and collation per key column */
3779 {
3783 /* The default collation is pinned, so don't bother recording it */
3786 {
3789 }
3790 }
3795 /*
3796 * The partitioning columns are made internally dependent on the table,
3797 * because we cannot drop any of them without dropping the whole table.
3798 * (ATExecDropColumn independently enforces that, but it's not bulletproof
3799 * so we need the dependencies too.)
3800 */
3802 {
3809 }
3811 /*
3812 * Also consider anything mentioned in partition expressions. External
3813 * references (e.g. functions) get NORMAL dependencies. Table columns
3814 * mentioned in the expressions are handled the same as plain partitioning
3815 * columns, i.e. they become internally dependent on the whole table.
3816 */
3821 DEPENDENCY_NORMAL,
3822 DEPENDENCY_INTERNAL,
3825 /*
3826 * We must invalidate the relcache so that the next
3827 * CommandCounterIncrement() will cause the same to be rebuilt using the
3828 * information in just created catalog entry.
3829 */
3831 }
3833 /*
3834 * RemovePartitionKeyByRelId
3835 * Remove pg_partitioned_table entry for a relation
3836 */
3837 void
3839 {
3840 Relation rel;
3841 HeapTuple tuple;
3848 relid);
3854 }
3856 /*
3857 * StorePartitionBound
3858 * Update pg_class tuple of rel to store the partition bound and set
3859 * relispartition to true
3860 *
3861 * If this is the default partition, also update the default partition OID in
3862 * pg_partitioned_table.
3863 *
3864 * Also, invalidate the parent's relcache, so that the next rebuild will load
3865 * the new partition's info into its partition descriptor. If there is a
3866 * default partition, we must invalidate its relcache entry as well.
3867 */
3868 void
3870 {
3871 Relation classRel;
3872 HeapTuple tuple,
3873 newtuple;
3877 Oid defaultPartOid;
3879 /* Update pg_class tuple */
3887 #ifdef USE_ASSERT_CHECKING
3888 {
3889 Form_pg_class classForm;
3897 }
3898 #endif
3900 /* Fill in relpartbound value */
3909 /* Also set the flag */
3912 /*
3913 * We already checked for no inheritance children, but reset
3914 * relhassubclass in case it was left over.
3915 */
3923 /*
3924 * If we're storing bounds for the default partition, update
3925 * pg_partitioned_table too.
3926 */
3931 /* Make these updates visible */
3934 /*
3935 * The partition constraint for the default partition depends on the
3936 * partition bounds of every other partition, so we must invalidate the
3937 * relcache entry for that partition every time a partition is added or
3938 * removed.
3939 */
3940 defaultPartOid =
3946 }