| blob | bc1c11a09f017d49dcf5fa3c50c73f71059ba8a2 |
1 /*-------------------------------------------------------------------------
2 *
3 * relcache.c
4 * POSTGRES relation descriptor cache code
5 *
6 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
12 *
13 *-------------------------------------------------------------------------
14 */
15 /*
16 * INTERFACE ROUTINES
17 * RelationCacheInitialize - initialize relcache (to empty)
18 * RelationCacheInitializePhase2 - finish initializing relcache
19 * RelationIdGetRelation - get a reldesc by relation id
20 * RelationClose - close an open relation
21 *
22 * NOTES
23 * The following code contains many undocumented hacks. Please be
24 * careful....
25 */
28 #include <sys/file.h>
29 #include <fcntl.h>
30 #include <unistd.h>
72 /*
73 * name of relcache init file, used to speed up backend startup
74 */
79 /*
80 * hardcoded tuple descriptors. see include/catalog/pg_attribute.h
81 */
88 /*
89 * Hash tables that index the relation cache
90 *
91 * We used to index the cache by both name and OID, but now there
92 * is only an index by OID.
93 */
95 {
96 Oid reloid;
97 Relation reldesc;
102 /*
103 * This flag is false until we have prepared the critical relcache entries
104 * that are needed to do indexscans on the tables read by relcache building.
105 */
108 /*
109 * This counter counts relcache inval events received since backend startup
110 * (but only for rels that are actually in cache). Presently, we use it only
111 * to detect whether data about to be written by write_relcache_init_file()
112 * might already be obsolete.
113 */
116 /*
117 * This list remembers the OIDs of the relations cached in the relcache
118 * init file.
119 */
122 /*
123 * This flag lets us optimize away work in AtEO(Sub)Xact_RelationCache().
124 */
128 /*
129 * macros to manipulate the lookup hashtables
130 */
131 #define RelationCacheInsert(RELATION) \
132 do { \
133 RelIdCacheEnt *idhentry; bool found; \
134 idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
135 (void *) &(RELATION->rd_id), \
136 HASH_ENTER, \
137 &found); \
139 idhentry->reldesc = RELATION; \
140 } while(0)
142 #define RelationIdCacheLookup(ID, RELATION) \
143 do { \
144 RelIdCacheEnt *hentry; \
145 hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
146 (void *) &(ID), HASH_FIND,NULL); \
147 if (hentry) \
148 RELATION = hentry->reldesc; \
149 else \
150 RELATION = NULL; \
151 } while(0)
153 #define RelationCacheDelete(RELATION) \
154 do { \
155 RelIdCacheEnt *idhentry; \
156 idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
157 (void *) &(RELATION->rd_id), \
158 HASH_REMOVE, NULL); \
159 if (idhentry == NULL) \
161 } while(0)
164 /*
165 * Special cache for opclass-related information
166 *
167 * Note: only default operators and support procs get cached, ie, those with
168 * lefttype = righttype = opcintype.
169 */
171 {
185 /* non-export function prototypes */
214 StrategyNumber maxStrategyNumber,
215 StrategyNumber maxSupportNumber,
216 AttrNumber maxAttributeNumber);
218 StrategyNumber numStrats,
219 StrategyNumber numSupport);
222 /*
223 * ScanPgRelation
224 *
225 * This is used by RelationBuildDesc to find a pg_class
226 * tuple matching targetRelId. The caller must hold at least
227 * AccessShareLock on the target relid to prevent concurrent-update
228 * scenarios --- else our SnapshotNow scan might fail to find any
229 * version that it thinks is live.
230 *
231 * NB: the returned tuple has been copied into palloc'd storage
232 * and must eventually be freed with heap_freetuple.
233 */
234 static HeapTuple
236 {
237 HeapTuple pg_class_tuple;
238 Relation pg_class_desc;
239 SysScanDesc pg_class_scan;
242 /*
243 * form a scan key
244 */
246 ObjectIdAttributeNumber,
250 /*
251 * Open pg_class and fetch a tuple. Force heap scan if we haven't yet
252 * built the critical relcache entries (this includes initdb and startup
253 * without a pg_internal.init file). The caller can also force a heap
254 * scan by setting indexOK == false.
255 */
259 SnapshotNow,
264 /*
265 * Must copy tuple before releasing buffer.
266 */
270 /* all done */
275 }
277 /*
278 * AllocateRelationDesc
279 *
280 * This is used to allocate memory for a new relation descriptor
281 * and initialize the rd_rel field.
282 *
283 * If 'relation' is NULL, allocate a new RelationData object.
284 * If not, reuse the given object (that path is taken only when
285 * we have to rebuild a relcache entry during RelationClearRelation).
286 */
287 static Relation
289 {
290 MemoryContext oldcxt;
291 Form_pg_class relationForm;
293 /* Relcache entries must live in CacheMemoryContext */
296 /*
297 * allocate space for new relation descriptor, if needed
298 */
302 /*
303 * clear all fields of reldesc
304 */
309 /* make sure relation is marked as having no open file yet */
312 /*
313 * Copy the relation tuple form
314 *
315 * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. The
316 * variable-length fields (relacl, reloptions) are NOT stored in the
317 * relcache --- there'd be little point in it, since we don't copy the
318 * tuple's nulls bitmap and hence wouldn't know if the values are valid.
319 * Bottom line is that relacl *cannot* be retrieved from the relcache. Get
320 * it from the syscache if you need it. The same goes for the original
321 * form of reloptions (however, we do store the parsed form of reloptions
322 * in rd_options).
323 */
328 /* initialize relation tuple form */
331 /* and allocate attribute tuple form storage */
334 /* which we mark as a reference-counted tupdesc */
340 }
342 /*
343 * RelationParseRelOptions
344 * Convert pg_class.reloptions into pre-parsed rd_options
345 *
346 * tuple is the real pg_class tuple (not rd_rel!) for relation
347 *
348 * Note: rd_rel and (if an index) rd_am must be valid already
349 */
350 static void
352 {
353 Datum datum;
359 /* Fall out if relkind should not have options */
361 {
369 }
371 /*
372 * Fetch reloptions from tuple; have to use a hardwired descriptor because
373 * we might not have any other for pg_class yet (consider executing this
374 * code for pg_class itself)
375 */
377 Anum_pg_class_reloptions,
383 /* Parse into appropriate format; don't error out here */
385 {
400 }
402 /* Copy parsed data into CacheMemoryContext */
404 {
408 }
409 }
411 /*
412 * RelationBuildTupleDesc
413 *
414 * Form the relation's tuple descriptor from information in
415 * the pg_attribute, pg_attrdef & pg_constraint system catalogs.
416 */
417 static void
419 {
420 HeapTuple pg_attribute_tuple;
421 Relation pg_attribute_desc;
422 SysScanDesc pg_attribute_scan;
429 /* copy some fields from pg_class row to rd_att */
438 /*
439 * Form a scan key that selects only user attributes (attnum > 0).
440 * (Eliminating system attribute rows at the index level is lots faster
441 * than fetching them.)
442 */
444 Anum_pg_attribute_attrelid,
448 Anum_pg_attribute_attnum,
452 /*
453 * Open pg_attribute and begin a scan. Force heap scan if we haven't yet
454 * built the critical relcache entries (this includes initdb and startup
455 * without a pg_internal.init file).
456 */
459 AttributeRelidNumIndexId,
460 criticalRelcachesBuilt,
461 SnapshotNow,
464 /*
465 * add attribute data to relation->rd_att
466 */
470 {
471 Form_pg_attribute attp;
481 attp,
482 ATTRIBUTE_TUPLE_SIZE);
484 /* Update constraint/default info */
489 {
497 ndef++;
498 }
499 need--;
502 }
504 /*
505 * end the scan and close the attribute relation
506 */
514 /*
515 * The attcacheoff values we read from pg_attribute should all be -1
516 * ("unknown"). Verify this if assert checking is on. They will be
517 * computed when and if needed during tuple access.
518 */
519 #ifdef USE_ASSERT_CHECKING
520 {
525 }
526 #endif
528 /*
529 * However, we can easily set the attcacheoff value for the first
530 * attribute: it must be zero. This eliminates the need for special cases
531 * for attnum=1 that used to exist in fastgetattr() and index_getattr().
532 */
536 /*
537 * Set up constraint/default info
538 */
540 {
544 {
548 else
552 }
553 else
557 {
563 }
564 else
566 }
567 else
568 {
571 }
572 }
574 /*
575 * RelationBuildRuleLock
576 *
577 * Form the relation's rewrite rules from information in
578 * the pg_rewrite system catalog.
579 *
580 * Note: The rule parsetrees are potentially very complex node structures.
581 * To allow these trees to be freed when the relcache entry is flushed,
582 * we make a private memory context to hold the RuleLock information for
583 * each relcache entry that has associated rules. The context is used
584 * just for rule info, not for any other subsidiary data of the relcache
585 * entry, because that keeps the update logic in RelationClearRelation()
586 * manageable. The other subsidiary data structures are simple enough
587 * to be easy to free explicitly, anyway.
588 */
589 static void
591 {
592 MemoryContext rulescxt;
593 MemoryContext oldcxt;
594 HeapTuple rewrite_tuple;
595 Relation rewrite_desc;
596 TupleDesc rewrite_tupdesc;
597 SysScanDesc rewrite_scan;
598 ScanKeyData key;
604 /*
605 * Make the private context. Parameters are set on the assumption that
606 * it'll probably not contain much data.
607 */
610 ALLOCSET_SMALL_MINSIZE,
611 ALLOCSET_SMALL_INITSIZE,
612 ALLOCSET_SMALL_MAXSIZE);
615 /*
616 * allocate an array to hold the rewrite rules (the array is extended if
617 * necessary)
618 */
624 /*
625 * form a scan key
626 */
628 Anum_pg_rewrite_ev_class,
632 /*
633 * open pg_rewrite and begin a scan
634 *
635 * Note: since we scan the rules using RewriteRelRulenameIndexId, we will
636 * be reading the rules in name order, except possibly during
637 * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
638 * ensures that rules will be fired in name order.
639 */
643 RewriteRelRulenameIndexId,
648 {
651 Datum rule_datum;
665 /*
666 * Must use heap_getattr to fetch ev_action and ev_qual. Also, the
667 * rule strings are often large enough to be toasted. To avoid
668 * leaking memory in the caller's context, do the detoasting here so
669 * we can free the detoasted version.
670 */
672 Anum_pg_rewrite_ev_action,
673 rewrite_tupdesc,
683 Anum_pg_rewrite_ev_qual,
684 rewrite_tupdesc,
693 /*
694 * We want the rule's table references to be checked as though by the
695 * table owner, not the user referencing the rule. Therefore, scan
696 * through the rule's actions and set the checkAsUser field on all
697 * rtable entries. We have to look at the qual as well, in case it
698 * contains sublinks.
699 *
700 * The reason for doing this when the rule is loaded, rather than when
701 * it is stored, is that otherwise ALTER TABLE OWNER would have to
702 * grovel through stored rules to update checkAsUser fields. Scanning
703 * the rule tree during load is relatively cheap (compared to
704 * constructing it in the first place), so we do it here.
705 */
710 {
714 }
716 }
718 /*
719 * end the scan and close the attribute relation
720 */
724 /*
725 * there might not be any rules (if relhasrules is out-of-date)
726 */
728 {
733 }
735 /*
736 * form a RuleLock and insert into relation
737 */
743 }
745 /*
746 * equalRuleLocks
747 *
748 * Determine whether two RuleLocks are equivalent
749 *
750 * Probably this should be in the rules code someplace...
751 */
752 static bool
754 {
757 /*
758 * As of 7.3 we assume the rule ordering is repeatable, because
759 * RelationBuildRuleLock should read 'em in a consistent order. So just
760 * compare corresponding slots.
761 */
763 {
769 {
785 }
786 }
790 }
793 /*
794 * RelationBuildDesc
795 *
796 * Build a relation descriptor --- either a new one, or by
797 * recycling the given old relation object. The latter case
798 * supports rebuilding a relcache entry without invalidating
799 * pointers to it. The caller must hold at least
800 * AccessShareLock on the target relid.
801 *
802 * Returns NULL if no pg_class row could be found for the given relid
803 * (suggesting we are trying to access a just-deleted relation).
804 * Any other error is reported via elog.
805 */
806 static Relation
808 {
809 Relation relation;
810 Oid relid;
811 HeapTuple pg_class_tuple;
812 Form_pg_class relp;
813 MemoryContext oldcxt;
815 /*
816 * find the tuple in pg_class corresponding to the given relation id
817 */
820 /*
821 * if no such tuple exists, return NULL
822 */
826 /*
827 * get information from the pg_class_tuple
828 */
832 /*
833 * allocate storage for the relation descriptor, and copy pg_class_tuple
834 * to relation->rd_rel.
835 */
838 /*
839 * initialize the relation's relation id (relation->rd_id)
840 */
843 /*
844 * normal relations are not nailed into the cache; nor can a pre-existing
845 * relation be new. It could be temp though. (Actually, it could be new
846 * too, but it's okay to forget that fact if forced to flush the entry.)
847 */
854 /*
855 * initialize the tuple descriptor (relation->rd_att).
856 */
859 /*
860 * Fetch rules and triggers that affect this relation
861 */
864 else
865 {
868 }
872 else
875 /*
876 * if it's an index, initialize index-related information
877 */
881 /* extract reloptions if any */
884 /*
885 * initialize the relation lock manager information
886 */
889 /*
890 * initialize physical addressing information for the relation
891 */
894 /* make sure relation is marked as having no open file yet */
897 /*
898 * now we can free the memory allocated for pg_class_tuple
899 */
902 /*
903 * Insert newly created relation into relcache hash tables.
904 */
909 /* It's fully valid */
913 }
915 /*
916 * Initialize the physical addressing info (RelFileNode) for a relcache entry
917 */
918 static void
920 {
923 else
927 else
930 }
932 /*
933 * Initialize index-access-method support data for an index relation
934 */
935 void
937 {
938 HeapTuple tuple;
939 Form_pg_am aform;
940 Datum indclassDatum;
941 Datum indoptionDatum;
945 MemoryContext indexcxt;
946 MemoryContext oldcontext;
948 uint16 amstrategies;
949 uint16 amsupport;
951 /*
952 * Make a copy of the pg_index entry for the index. Since pg_index
953 * contains variable-length and possibly-null fields, we have to do this
954 * honestly rather than just treating it as a Form_pg_index struct.
955 */
968 /*
969 * Make a copy of the pg_am entry for the index's access method
970 */
989 /*
990 * Make the private context to hold index access info. The reason we need
991 * a context, and not just a couple of pallocs, is so that we won't leak
992 * any subsidiary info attached to fmgr lookup records.
993 *
994 * Context parameters are set on the assumption that it'll probably not
995 * contain much data.
996 */
999 ALLOCSET_SMALL_MINSIZE,
1000 ALLOCSET_SMALL_INITSIZE,
1001 ALLOCSET_SMALL_MAXSIZE);
1004 /*
1005 * Allocate arrays to hold data
1006 */
1019 else
1023 {
1030 }
1031 else
1032 {
1035 }
1040 /*
1041 * indclass cannot be referenced directly through the C struct, because it
1042 * comes after the variable-width indkey field. Must extract the datum
1043 * the hard way...
1044 */
1046 Anum_pg_index_indclass,
1052 /*
1053 * Fill the operator and support procedure OID arrays, as well as the info
1054 * about opfamilies and opclass input types. (aminfo and supportinfo are
1055 * left as zeroes, and are filled on-the-fly when used)
1056 */
1062 /*
1063 * Similarly extract indoption and copy it to the cache entry
1064 */
1066 Anum_pg_index_indoption,
1073 /*
1074 * expressions and predicate cache will be filled later
1075 */
1079 }
1081 /*
1082 * IndexSupportInitialize
1083 * Initializes an index's cached opclass information,
1084 * given the index's pg_index.indclass entry.
1085 *
1086 * Data is returned into *indexOperator, *indexSupport, *opFamily, and
1087 * *opcInType, which are arrays allocated by the caller.
1088 *
1089 * The caller also passes maxStrategyNumber, maxSupportNumber, and
1090 * maxAttributeNumber, since these indicate the size of the arrays
1091 * it has allocated --- but in practice these numbers must always match
1092 * those obtainable from the system catalog entries for the index and
1093 * access method.
1094 */
1095 static void
1101 StrategyNumber maxStrategyNumber,
1102 StrategyNumber maxSupportNumber,
1103 AttrNumber maxAttributeNumber)
1104 {
1108 {
1114 /* look up the info for this opclass, using a cache */
1116 maxStrategyNumber,
1117 maxSupportNumber);
1119 /* copy cached data into relcache entry */
1130 }
1131 }
1133 /*
1134 * LookupOpclassInfo
1135 *
1136 * This routine maintains a per-opclass cache of the information needed
1137 * by IndexSupportInitialize(). This is more efficient than relying on
1138 * the catalog cache, because we can load all the info about a particular
1139 * opclass in a single indexscan of pg_amproc or pg_amop.
1140 *
1141 * The information from pg_am about expected range of strategy and support
1142 * numbers is passed in, rather than being looked up, mainly because the
1143 * caller will have it already.
1144 *
1145 * Note there is no provision for flushing the cache. This is OK at the
1146 * moment because there is no way to ALTER any interesting properties of an
1147 * existing opclass --- all you can do is drop it, which will result in
1148 * a useless but harmless dead entry in the cache. To support altering
1149 * opclass membership (not the same as opfamily membership!), we'd need to
1150 * be able to flush this cache as well as the contents of relcache entries
1151 * for indexes.
1152 */
1155 StrategyNumber numStrats,
1156 StrategyNumber numSupport)
1157 {
1160 Relation rel;
1161 SysScanDesc scan;
1163 HeapTuple htup;
1167 {
1168 /* First time through: initialize the opclass cache */
1169 HASHCTL ctl;
1180 }
1187 {
1188 /* Need to allocate memory for new entry */
1197 else
1204 else
1206 }
1207 else
1208 {
1211 }
1213 /*
1214 * When testing for cache-flush hazards, we intentionally disable the
1215 * operator class cache and force reloading of the info on each call.
1216 * This is helpful because we want to test the case where a cache flush
1217 * occurs while we are loading the info, and it's very hard to provoke
1218 * that if this happens only once per opclass per backend.
1219 */
1220 #if defined(CLOBBER_CACHE_ALWAYS)
1222 #endif
1227 /*
1228 * Need to fill in new entry.
1229 *
1230 * To avoid infinite recursion during startup, force heap scans if we're
1231 * looking up info for the opclasses used by the indexes we would like to
1232 * reference here.
1233 */
1238 /*
1239 * We have to fetch the pg_opclass row to determine its opfamily and
1240 * opcintype, which are needed to look up the operators and functions.
1241 * It'd be convenient to use the syscache here, but that probably doesn't
1242 * work while bootstrapping.
1243 */
1245 ObjectIdAttributeNumber,
1253 {
1258 }
1259 else
1266 /*
1267 * Scan pg_amop to obtain operators for the opclass. We only fetch the
1268 * default ones (those with lefttype = righttype = opcintype).
1269 */
1271 {
1273 Anum_pg_amop_amopfamily,
1277 Anum_pg_amop_amoplefttype,
1281 Anum_pg_amop_amoprighttype,
1289 {
1298 }
1302 }
1304 /*
1305 * Scan pg_amproc to obtain support procs for the opclass. We only fetch
1306 * the default ones (those with lefttype = righttype = opcintype).
1307 */
1309 {
1311 Anum_pg_amproc_amprocfamily,
1315 Anum_pg_amproc_amproclefttype,
1319 Anum_pg_amproc_amprocrighttype,
1327 {
1337 }
1341 }
1345 }
1348 /*
1349 * formrdesc
1350 *
1351 * This is a special cut-down version of RelationBuildDesc()
1352 * used by RelationCacheInitializePhase2() in initializing the relcache.
1353 * The relation descriptor is built just from the supplied parameters,
1354 * without actually looking at any system table entries. We cheat
1355 * quite a lot since we only need to work for a few basic system
1356 * catalogs.
1357 *
1358 * formrdesc is currently used for: pg_class, pg_attribute, pg_proc,
1359 * and pg_type (see RelationCacheInitializePhase2).
1360 *
1361 * Note that these catalogs can't have constraints (except attnotnull),
1362 * default values, rules, or triggers, since we don't cope with any of that.
1363 *
1364 * NOTE: we assume we are already switched into CacheMemoryContext.
1365 */
1366 static void
1369 {
1370 Relation relation;
1374 /*
1375 * allocate new relation desc, clear all fields of reldesc
1376 */
1381 /* make sure relation is marked as having no open file yet */
1384 /*
1385 * initialize reference count: 1 because it is nailed in cache
1386 */
1389 /*
1390 * all entries built with this routine are nailed-in-cache; none are for
1391 * new or temp relations.
1392 */
1398 /*
1399 * initialize relation tuple form
1400 *
1401 * The data we insert here is pretty incomplete/bogus, but it'll serve to
1402 * get us launched. RelationCacheInitializePhase2() will read the real
1403 * data from pg_class and replace what we've done here.
1404 */
1411 /*
1412 * It's important to distinguish between shared and non-shared relations,
1413 * even at bootstrap time, to make sure we know where they are stored. At
1414 * present, all relations that formrdesc is used for are not shared.
1415 */
1424 /*
1425 * initialize attribute tuple form
1426 *
1427 * Unlike the case with the relation tuple, this data had better be right
1428 * because it will never be replaced. The input values must be correctly
1429 * defined by macros in src/include/catalog/ headers.
1430 */
1437 /*
1438 * initialize tuple desc info
1439 */
1442 {
1445 ATTRIBUTE_TUPLE_SIZE);
1447 /* make sure attcacheoff is valid */
1449 }
1451 /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
1454 /* mark not-null status */
1456 {
1461 }
1463 /*
1464 * initialize relation id from info in att array (my, this is ugly)
1465 */
1469 /*
1470 * initialize the relation lock manager information
1471 */
1474 /*
1475 * initialize physical addressing information for the relation
1476 */
1479 /*
1480 * initialize the rel-has-index flag, using hardwired knowledge
1481 */
1483 {
1484 /* In bootstrap mode, we have no indexes */
1486 }
1487 else
1488 {
1489 /* Otherwise, all the rels formrdesc is used for have indexes */
1491 }
1493 /*
1494 * add new reldesc to relcache
1495 */
1498 /* It's fully valid */
1500 }
1503 /* ----------------------------------------------------------------
1504 * Relation Descriptor Lookup Interface
1505 * ----------------------------------------------------------------
1506 */
1508 /*
1509 * RelationIdGetRelation
1510 *
1511 * Lookup a reldesc by OID; make one if not already in cache.
1512 *
1513 * Returns NULL if no pg_class row could be found for the given relid
1514 * (suggesting we are trying to access a just-deleted relation).
1515 * Any other error is reported via elog.
1516 *
1517 * NB: caller should already have at least AccessShareLock on the
1518 * relation ID, else there are nasty race conditions.
1519 *
1520 * NB: relation ref count is incremented, or set to 1 if new entry.
1521 * Caller should eventually decrement count. (Usually,
1522 * that happens by calling RelationClose().)
1523 */
1524 Relation
1526 {
1527 Relation rd;
1529 /*
1530 * first try to find reldesc in the cache
1531 */
1535 {
1537 /* revalidate nailed index if necessary */
1541 }
1543 /*
1544 * no reldesc in the cache, so have RelationBuildDesc() build one and add
1545 * it.
1546 */
1551 }
1553 /* ----------------------------------------------------------------
1554 * cache invalidation support routines
1555 * ----------------------------------------------------------------
1556 */
1558 /*
1559 * RelationIncrementReferenceCount
1560 * Increments relation reference count.
1561 *
1562 * Note: bootstrap mode has its own weird ideas about relation refcount
1563 * behavior; we ought to fix it someday, but for now, just disable
1564 * reference count ownership tracking in bootstrap mode.
1565 */
1566 void
1568 {
1573 }
1575 /*
1576 * RelationDecrementReferenceCount
1577 * Decrements relation reference count.
1578 */
1579 void
1581 {
1586 }
1588 /*
1589 * RelationClose - close an open relation
1590 *
1591 * Actually, we just decrement the refcount.
1592 *
1593 * NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries
1594 * will be freed as soon as their refcount goes to zero. In combination
1595 * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
1596 * to catch references to already-released relcache entries. It slows
1597 * things down quite a bit, however.
1598 */
1599 void
1601 {
1602 /* Note: no locking manipulations needed */
1605 #ifdef RELCACHE_FORCE_RELEASE
1610 #endif
1611 }
1613 /*
1614 * RelationReloadIndexInfo - reload minimal information for an open index
1615 *
1616 * This function is used only for indexes. A relcache inval on an index
1617 * can mean that its pg_class or pg_index row changed. There are only
1618 * very limited changes that are allowed to an existing index's schema,
1619 * so we can update the relcache entry without a complete rebuild; which
1620 * is fortunate because we can't rebuild an index entry that is "nailed"
1621 * and/or in active use. We support full replacement of the pg_class row,
1622 * as well as updates of a few simple fields of the pg_index row.
1623 *
1624 * We can't necessarily reread the catalog rows right away; we might be
1625 * in a failed transaction when we receive the SI notification. If so,
1626 * RelationClearRelation just marks the entry as invalid by setting
1627 * rd_isvalid to false. This routine is called to fix the entry when it
1628 * is next needed.
1629 *
1630 * We assume that at the time we are called, we have at least AccessShareLock
1631 * on the target index. (Note: in the calls from RelationClearRelation,
1632 * this is legitimate because we know the rel has positive refcount.)
1633 */
1634 static void
1636 {
1638 HeapTuple pg_class_tuple;
1639 Form_pg_class relp;
1641 /* Should be called only for invalidated indexes */
1644 /* Should be closed at smgr level */
1647 /*
1648 * Read the pg_class row
1649 *
1650 * Don't try to use an indexscan of pg_class_oid_index to reload the info
1651 * for pg_class_oid_index ...
1652 */
1660 /* Reload reloptions in case they changed */
1664 /* done with pg_class tuple */
1666 /* We must recalculate physical address in case it changed */
1668 /* Must reset targblock and fsm_nblocks_cache in case rel was truncated */
1671 /* Must free any AM cached data, too */
1676 /*
1677 * For a non-system index, there are fields of the pg_index row that are
1678 * allowed to change, so re-read that row and update the relcache entry.
1679 * Most of the info derived from pg_index (such as support function lookup
1680 * info) cannot change, and indeed the whole point of this routine is to
1681 * update the relcache entry without clobbering that data; so wholesale
1682 * replacement is not appropriate.
1683 */
1685 {
1686 HeapTuple tuple;
1687 Form_pg_index index;
1704 }
1706 /* Okay, now it's valid again */
1708 }
1710 /*
1711 * RelationClearRelation
1712 *
1713 * Physically blow away a relation cache entry, or reset it and rebuild
1714 * it from scratch (that is, from catalog entries). The latter path is
1715 * usually used when we are notified of a change to an open relation
1716 * (one with refcount > 0). However, this routine just does whichever
1717 * it's told to do; callers must determine which they want.
1718 *
1719 * NB: when rebuilding, we'd better hold some lock on the relation.
1720 * In current usages this is presumed true because it has refcnt > 0.
1721 */
1722 static void
1724 {
1726 MemoryContext oldcxt;
1728 /*
1729 * Make sure smgr and lower levels close the relation's files, if they
1730 * weren't closed already. If the relation is not getting deleted, the
1731 * next smgr access should reopen the files automatically. This ensures
1732 * that the low-level file access state is updated after, say, a vacuum
1733 * truncation.
1734 */
1737 /*
1738 * Never, never ever blow away a nailed-in system relation, because we'd
1739 * be unable to recover. However, we must reset rd_targblock, in case we
1740 * got called because of a relation cache flush that was triggered by
1741 * VACUUM.
1742 *
1743 * If it's a nailed index, then we need to re-read the pg_class row to see
1744 * if its relfilenode changed. We can't necessarily do that here, because
1745 * we might be in a failed transaction. We assume it's okay to do it if
1746 * there are open references to the relcache entry (cf notes for
1747 * AtEOXact_RelationCache). Otherwise just mark the entry as possibly
1748 * invalid, and it'll be fixed when next opened.
1749 */
1751 {
1755 {
1759 }
1761 }
1763 /*
1764 * Even non-system indexes should not be blown away if they are open and
1765 * have valid index support information. This avoids problems with active
1766 * use of the index support information. As with nailed indexes, we
1767 * re-read the pg_class row to handle possible physical relocation of the
1768 * index, and we check for pg_index updates too.
1769 */
1773 {
1777 }
1779 /*
1780 * Remove relation from hash tables
1781 *
1782 * Note: we might be reinserting it momentarily, but we must not have it
1783 * visible in the hash tables until it's valid again, so don't try to
1784 * optimize this away...
1785 */
1790 /* Clear out catcache's entries for this relation */
1793 /*
1794 * Free all the subsidiary data structures of the relcache entry. We
1795 * cannot free rd_att if we are trying to rebuild the entry, however,
1796 * because pointers to it may be cached in various places. The rule
1797 * manager might also have pointers into the rewrite rules. So to begin
1798 * with, we can only get rid of these fields:
1799 */
1814 /*
1815 * If we're really done with the relcache entry, blow it away. But if
1816 * someone is still using it, reconstruct the whole deal without moving
1817 * the physical RelationData record (so that the someone's pointer is
1818 * still valid).
1819 */
1821 {
1822 /* ok to zap remaining substructure */
1824 /* can't use DecrTupleDescRefCount here */
1831 }
1832 else
1833 {
1834 /*
1835 * When rebuilding an open relcache entry, must preserve ref count and
1836 * rd_createSubid/rd_newRelfilenodeSubid state. Also attempt to
1837 * preserve the tupledesc and rewrite-rule substructures in place.
1838 * (Note: the refcount mechanism for tupledescs may eventually ensure
1839 * that we don't really need to preserve the tupledesc in-place, but
1840 * for now there are still a lot of places that assume an open rel's
1841 * tupledesc won't move.)
1842 *
1843 * Note that this process does not touch CurrentResourceOwner; which
1844 * is good because whatever ref counts the entry may have do not
1845 * necessarily belong to that resource owner.
1846 */
1857 {
1858 /* Should only get here if relation was deleted */
1867 }
1874 {
1875 /* needn't flush typcache here */
1880 }
1881 else
1882 {
1887 }
1889 {
1894 }
1895 else
1896 {
1899 }
1900 }
1901 }
1903 /*
1904 * RelationFlushRelation
1905 *
1906 * Rebuild the relation if it is open (refcount > 0), else blow it away.
1907 */
1908 static void
1910 {
1915 {
1916 /*
1917 * New relcache entries are always rebuilt, not flushed; else we'd
1918 * forget the "new" status of the relation, which is a useful
1919 * optimization to have. Ditto for the new-relfilenode status.
1920 */
1922 }
1923 else
1924 {
1925 /*
1926 * Pre-existing rels can be dropped from the relcache if not open.
1927 */
1929 }
1932 }
1934 /*
1935 * RelationForgetRelation - unconditionally remove a relcache entry
1936 *
1937 * External interface for destroying a relcache entry when we
1938 * drop the relation.
1939 */
1940 void
1942 {
1943 Relation relation;
1953 /* Unconditionally destroy the relcache entry */
1955 }
1957 /*
1958 * RelationCacheInvalidateEntry
1959 *
1960 * This routine is invoked for SI cache flush messages.
1961 *
1962 * Any relcache entry matching the relid must be flushed. (Note: caller has
1963 * already determined that the relid belongs to our database or is a shared
1964 * relation.)
1965 *
1966 * We used to skip local relations, on the grounds that they could
1967 * not be targets of cross-backend SI update messages; but it seems
1968 * safer to process them, so that our *own* SI update messages will
1969 * have the same effects during CommandCounterIncrement for both
1970 * local and nonlocal relations.
1971 */
1972 void
1974 {
1975 Relation relation;
1980 {
1981 relcacheInvalsReceived++;
1983 }
1984 }
1986 /*
1987 * RelationCacheInvalidate
1988 * Blow away cached relation descriptors that have zero reference counts,
1989 * and rebuild those with positive reference counts. Also reset the smgr
1990 * relation cache.
1991 *
1992 * This is currently used only to recover from SI message buffer overflow,
1993 * so we do not touch new-in-transaction relations; they cannot be targets
1994 * of cross-backend SI updates (and our own updates now go through a
1995 * separate linked list that isn't limited by the SI message buffer size).
1996 * Likewise, we need not discard new-relfilenode-in-transaction hints,
1997 * since any invalidation of those would be a local event.
1998 *
1999 * We do this in two phases: the first pass deletes deletable items, and
2000 * the second one rebuilds the rebuildable items. This is essential for
2001 * safety, because hash_seq_search only copes with concurrent deletion of
2002 * the element it is currently visiting. If a second SI overflow were to
2003 * occur while we are walking the table, resulting in recursive entry to
2004 * this routine, we could crash because the inner invocation blows away
2005 * the entry next to be visited by the outer scan. But this way is OK,
2006 * because (a) during the first pass we won't process any more SI messages,
2007 * so hash_seq_search will complete safely; (b) during the second pass we
2008 * only hold onto pointers to nondeletable entries.
2009 *
2010 * The two-phase approach also makes it easy to ensure that we process
2011 * nailed-in-cache indexes before other nondeletable items, and that we
2012 * process pg_class_oid_index first of all. In scenarios where a nailed
2013 * index has been given a new relfilenode, we have to detect that update
2014 * before the nailed index is used in reloading any other relcache entry.
2015 */
2016 void
2018 {
2019 HASH_SEQ_STATUS status;
2021 Relation relation;
2026 /* Phase 1 */
2030 {
2033 /* Must close all smgr references to avoid leaving dangling ptrs */
2036 /* Ignore new relations, since they are never SI targets */
2040 relcacheInvalsReceived++;
2043 {
2044 /* Delete this entry immediately */
2047 }
2048 else
2049 {
2050 /*
2051 * Add this entry to list of stuff to rebuild in second pass.
2052 * pg_class_oid_index goes on the front of rebuildFirstList, other
2053 * nailed indexes on the back, and everything else into
2054 * rebuildList (in no particular order).
2055 */
2058 {
2061 else
2063 }
2064 else
2066 }
2067 }
2069 /*
2070 * Now zap any remaining smgr cache entries. This must happen before we
2071 * start to rebuild entries, since that may involve catalog fetches which
2072 * will re-open catalog files.
2073 */
2076 /* Phase 2: rebuild the items found to need rebuild in phase 1 */
2078 {
2081 }
2084 {
2087 }
2089 }
2091 /*
2092 * AtEOXact_RelationCache
2093 *
2094 * Clean up the relcache at main-transaction commit or abort.
2095 *
2096 * Note: this must be called *before* processing invalidation messages.
2097 * In the case of abort, we don't want to try to rebuild any invalidated
2098 * cache entries (since we can't safely do database accesses). Therefore
2099 * we must reset refcnts before handling pending invalidations.
2100 *
2101 * As of PostgreSQL 8.1, relcache refcnts should get released by the
2102 * ResourceOwner mechanism. This routine just does a debugging
2103 * cross-check that no pins remain. However, we also need to do special
2104 * cleanup when the current transaction created any relations or made use
2105 * of forced index lists.
2106 */
2107 void
2109 {
2110 HASH_SEQ_STATUS status;
2113 /*
2114 * To speed up transaction exit, we want to avoid scanning the relcache
2115 * unless there is actually something for this routine to do. Other than
2116 * the debug-only Assert checks, most transactions don't create any work
2117 * for us to do here, so we keep a static flag that gets set if there is
2118 * anything to do. (Currently, this means either a relation is created in
2119 * the current xact, or one is given a new relfilenode, or an index list
2120 * is forced.) For simplicity, the flag remains set till end of top-level
2121 * transaction, even though we could clear it at subtransaction end in
2122 * some cases.
2123 */
2125 #ifdef USE_ASSERT_CHECKING
2126 && !assert_enabled
2127 #endif
2128 )
2134 {
2137 /*
2138 * The relcache entry's ref count should be back to its normal
2139 * not-in-a-transaction state: 0 unless it's nailed in cache.
2140 *
2141 * In bootstrap mode, this is NOT true, so don't check it --- the
2142 * bootstrap code expects relations to stay open across start/commit
2143 * transaction calls. (That seems bogus, but it's not worth fixing.)
2144 */
2145 #ifdef USE_ASSERT_CHECKING
2147 {
2152 }
2153 #endif
2155 /*
2156 * Is it a relation created in the current transaction?
2157 *
2158 * During commit, reset the flag to zero, since we are now out of the
2159 * creating transaction. During abort, simply delete the relcache
2160 * entry --- it isn't interesting any longer. (NOTE: if we have
2161 * forgotten the new-ness of a new relation due to a forced cache
2162 * flush, the entry will get deleted anyway by shared-cache-inval
2163 * processing of the aborted pg_class insertion.)
2164 */
2166 {
2169 else
2170 {
2173 }
2174 }
2176 /*
2177 * Likewise, reset the hint about the relfilenode being new.
2178 */
2181 /*
2182 * Flush any temporary index list.
2183 */
2185 {
2190 }
2191 }
2193 /* Once done with the transaction, we can reset need_eoxact_work */
2195 }
2197 /*
2198 * AtEOSubXact_RelationCache
2199 *
2200 * Clean up the relcache at sub-transaction commit or abort.
2201 *
2202 * Note: this must be called *before* processing invalidation messages.
2203 */
2204 void
2206 SubTransactionId parentSubid)
2207 {
2208 HASH_SEQ_STATUS status;
2211 /*
2212 * Skip the relcache scan if nothing to do --- see notes for
2213 * AtEOXact_RelationCache.
2214 */
2221 {
2224 /*
2225 * Is it a relation created in the current subtransaction?
2226 *
2227 * During subcommit, mark it as belonging to the parent, instead.
2228 * During subabort, simply delete the relcache entry.
2229 */
2231 {
2234 else
2235 {
2239 }
2240 }
2242 /*
2243 * Likewise, update or drop any new-relfilenode-in-subtransaction
2244 * hint.
2245 */
2247 {
2250 else
2252 }
2254 /*
2255 * Flush any temporary index list.
2256 */
2258 {
2263 }
2264 }
2265 }
2267 /*
2268 * RelationCacheMarkNewRelfilenode
2269 *
2270 * Mark the rel as having been given a new relfilenode in the current
2271 * (sub) transaction. This is a hint that can be used to optimize
2272 * later operations on the rel in the same transaction.
2273 */
2274 void
2276 {
2277 /* Mark it... */
2279 /* ... and now we have eoxact cleanup work to do */
2281 }
2284 /*
2285 * RelationBuildLocalRelation
2286 * Build a relcache entry for an about-to-be-created relation,
2287 * and enter it into the relcache.
2288 */
2289 Relation
2291 Oid relnamespace,
2292 TupleDesc tupDesc,
2293 Oid relid,
2294 Oid reltablespace,
2296 {
2297 Relation rel;
2298 MemoryContext oldcxt;
2306 /*
2307 * check for creation of a rel that must be nailed in cache.
2308 *
2309 * XXX this list had better match RelationCacheInitializePhase2's list.
2310 */
2312 {
2322 }
2324 /*
2325 * check that hardwired list of shared rels matches what's in the
2326 * bootstrap .bki file. If you get a failure here during initdb, you
2327 * probably need to fix IsSharedRelation() to match whatever you've done
2328 * to the set of shared relations.
2329 */
2334 /*
2335 * switch to the cache context to create the relcache entry.
2336 */
2342 /*
2343 * allocate a new relation descriptor and fill in basic state fields.
2344 */
2350 /* make sure relation is marked as having no open file yet */
2353 /* mark it nailed if appropriate */
2358 /* it's being created in this transaction */
2362 /* must flag that we have rels created in this transaction */
2365 /* is it a temporary relation? */
2368 /*
2369 * create a new tuple descriptor from the one passed in. We do this
2370 * partly to copy it into the cache context, and partly because the new
2371 * relation can't have any defaults or constraints yet; they have to be
2372 * added in later steps, because they require additions to multiple system
2373 * catalogs. We can copy attnotnull constraints here, however.
2374 */
2379 {
2382 }
2385 {
2390 }
2392 /*
2393 * initialize relation tuple form (caller may add/override data later)
2394 */
2404 /* needed when bootstrapping: */
2407 /*
2408 * Insert relation physical and logical identifiers (OIDs) into the right
2409 * places. Note that the physical ID (relfilenode) is initially the same
2410 * as the logical ID (OID).
2411 */
2426 /*
2427 * Okay to insert into the relcache hash tables.
2428 */
2431 /*
2432 * done building relcache entry.
2433 */
2436 /* It's fully valid */
2439 /*
2440 * Caller expects us to pin the returned entry.
2441 */
2445 }
2447 /*
2448 * RelationCacheInitialize
2449 *
2450 * This initializes the relation descriptor cache. At the time
2451 * that this is invoked, we can't do database access yet (mainly
2452 * because the transaction subsystem is not up); all we are doing
2453 * is making an empty cache hashtable. This must be done before
2454 * starting the initialization transaction, because otherwise
2455 * AtEOXact_RelationCache would crash if that transaction aborts
2456 * before we can get the relcache set up.
2457 */
2459 #define INITRELCACHESIZE 400
2461 void
2463 {
2464 MemoryContext oldcxt;
2465 HASHCTL ctl;
2467 /*
2468 * switch to cache memory context
2469 */
2475 /*
2476 * create hashtable that indexes the relcache
2477 */
2486 }
2488 /*
2489 * RelationCacheInitializePhase2
2490 *
2491 * This is called as soon as the catcache and transaction system
2492 * are functional. At this point we can actually read data from
2493 * the system catalogs. We first try to read pre-computed relcache
2494 * entries from the pg_internal.init file. If that's missing or
2495 * broken, make phony entries for the minimum set of nailed-in-cache
2496 * relations. Then (unless bootstrapping) make sure we have entries
2497 * for the critical system indexes. Once we've done all this, we
2498 * have enough infrastructure to open any system catalog or use any
2499 * catcache. The last step is to rewrite pg_internal.init if needed.
2500 */
2501 void
2503 {
2504 HASH_SEQ_STATUS status;
2506 MemoryContext oldcxt;
2509 /*
2510 * switch to cache memory context
2511 */
2514 /*
2515 * Try to load the relcache cache file. If unsuccessful, bootstrap the
2516 * cache with pre-made descriptors for the critical "nailed-in" system
2517 * catalogs.
2518 */
2521 {
2534 }
2538 /* In bootstrap mode, the faked-up formrdesc info is all we'll have */
2542 /*
2543 * If we didn't get the critical system indexes loaded into relcache, do
2544 * so now. These are critical because the catcache and/or opclass cache
2545 * depend on them for fetches done during relcache load. Thus, we have an
2546 * infinite-recursion problem. We can break the recursion by doing
2547 * heapscans instead of indexscans at certain key spots. To avoid hobbling
2548 * performance, we only want to do that until we have the critical indexes
2549 * loaded into relcache. Thus, the flag criticalRelcachesBuilt is used to
2550 * decide whether to do heapscan or indexscan at the key spots, and we set
2551 * it true after we've loaded the critical indexes.
2552 *
2553 * The critical indexes are marked as "nailed in cache", partly to make it
2554 * easy for load_relcache_init_file to count them, but mainly because we
2555 * cannot flush and rebuild them once we've set criticalRelcachesBuilt to
2556 * true. (NOTE: perhaps it would be possible to reload them by
2557 * temporarily setting criticalRelcachesBuilt to false again. For now,
2558 * though, we just nail 'em in.)
2559 *
2560 * RewriteRelRulenameIndexId and TriggerRelidNameIndexId are not critical
2561 * in the same way as the others, because the critical catalogs don't
2562 * (currently) have any rules or triggers, and so these indexes can be
2563 * rebuilt without inducing recursion. However they are used during
2564 * relcache load when a rel does have rules or triggers, so we choose to
2565 * nail them for performance reasons.
2566 */
2568 {
2569 Relation ird;
2571 #define LOAD_CRIT_INDEX(indexoid) \
2572 do { \
2573 LockRelationOid(indexoid, AccessShareLock); \
2574 ird = RelationBuildDesc(indexoid, NULL); \
2575 if (ird == NULL) \
2577 indexoid); \
2578 ird->rd_isnailed = true; \
2579 ird->rd_refcnt = 1; \
2580 UnlockRelationOid(indexoid, AccessShareLock); \
2581 } while (0)
2596 }
2598 /*
2599 * Now, scan all the relcache entries and update anything that might be
2600 * wrong in the results from formrdesc or the relcache cache file. If we
2601 * faked up relcache entries using formrdesc, then read the real pg_class
2602 * rows and replace the fake entries with them. Also, if any of the
2603 * relcache entries have rules or triggers, load that info the hard way
2604 * since it isn't recorded in the cache file.
2605 */
2609 {
2612 /*
2613 * If it's a faked-up entry, read the real pg_class tuple.
2614 */
2616 {
2617 HeapTuple htup;
2618 Form_pg_class relp;
2628 /*
2629 * Copy tuple to relation->rd_rel. (See notes in
2630 * AllocateRelationDesc())
2631 */
2635 /* Update rd_options while we have the tuple */
2640 /*
2641 * Also update the derived fields in rd_att.
2642 */
2648 }
2650 /*
2651 * Fix data that isn't saved in relcache cache file.
2652 */
2657 }
2659 /*
2660 * Lastly, write out a new relcache cache file if one is needed.
2661 */
2663 {
2664 /*
2665 * Force all the catcaches to finish initializing and thereby open the
2666 * catalogs and indexes they use. This will preload the relcache with
2667 * entries for all the most important system catalogs and indexes, so
2668 * that the init file will be most useful for future backends.
2669 */
2672 /* now write the file */
2674 }
2675 }
2677 /*
2678 * GetPgClassDescriptor -- get a predefined tuple descriptor for pg_class
2679 * GetPgIndexDescriptor -- get a predefined tuple descriptor for pg_index
2680 *
2681 * We need this kluge because we have to be able to access non-fixed-width
2682 * fields of pg_class and pg_index before we have the standard catalog caches
2683 * available. We use predefined data that's set up in just the same way as
2684 * the bootstrapped reldescs used by formrdesc(). The resulting tupdesc is
2685 * not 100% kosher: it does not have the correct rowtype OID in tdtypeid, nor
2686 * does it have a TupleConstr field. But it's good enough for the purpose of
2687 * extracting fields.
2688 */
2689 static TupleDesc
2691 {
2692 TupleDesc result;
2693 MemoryContext oldcxt;
2703 {
2705 /* make sure attcacheoff is valid */
2707 }
2709 /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
2712 /* Note: we don't bother to set up a TupleConstr entry */
2717 }
2719 static TupleDesc
2721 {
2724 /* Already done? */
2727 Desc_pg_class,
2731 }
2733 static TupleDesc
2735 {
2738 /* Already done? */
2741 Desc_pg_index,
2745 }
2747 static void
2749 {
2752 Relation adrel;
2753 SysScanDesc adscan;
2754 ScanKeyData skey;
2755 HeapTuple htup;
2756 Datum val;
2762 Anum_pg_attrdef_adrelid,
2772 {
2776 {
2783 else
2784 found++;
2787 Anum_pg_attrdef_adbin,
2793 else
2797 }
2802 }
2810 }
2812 static void
2814 {
2817 Relation conrel;
2818 SysScanDesc conscan;
2820 HeapTuple htup;
2821 Datum val;
2826 Anum_pg_constraint_conrelid,
2835 {
2838 /* We want check constraints only */
2849 /* Grab and test conbin is actually set */
2851 Anum_pg_constraint_conbin,
2859 found++;
2860 }
2868 }
2870 /*
2871 * RelationGetIndexList -- get a list of OIDs of indexes on this relation
2872 *
2873 * The index list is created only if someone requests it. We scan pg_index
2874 * to find relevant indexes, and add the list to the relcache entry so that
2875 * we won't have to compute it again. Note that shared cache inval of a
2876 * relcache entry will delete the old list and set rd_indexvalid to 0,
2877 * so that we must recompute the index list on next request. This handles
2878 * creation or deletion of an index.
2879 *
2880 * The returned list is guaranteed to be sorted in order by OID. This is
2881 * needed by the executor, since for index types that we obtain exclusive
2882 * locks on when updating the index, all backends must lock the indexes in
2883 * the same order or we will get deadlocks (see ExecOpenIndices()). Any
2884 * consistent ordering would do, but ordering by OID is easy.
2885 *
2886 * Since shared cache inval causes the relcache's copy of the list to go away,
2887 * we return a copy of the list palloc'd in the caller's context. The caller
2888 * may list_free() the returned list after scanning it. This is necessary
2889 * since the caller will typically be doing syscache lookups on the relevant
2890 * indexes, and syscache lookup could cause SI messages to be processed!
2891 *
2892 * We also update rd_oidindex, which this module treats as effectively part
2893 * of the index list. rd_oidindex is valid when rd_indexvalid isn't zero;
2894 * it is the pg_class OID of a unique index on OID when the relation has one,
2895 * and InvalidOid if there is no such index.
2896 */
2897 List *
2899 {
2900 Relation indrel;
2901 SysScanDesc indscan;
2902 ScanKeyData skey;
2903 HeapTuple htup;
2905 Oid oidIndex;
2906 MemoryContext oldcxt;
2908 /* Quick exit if we already computed the list. */
2912 /*
2913 * We build the list we intend to return (in the caller's context) while
2914 * doing the scan. After successfully completing the scan, we copy that
2915 * list into the relcache entry. This avoids cache-context memory leakage
2916 * if we get some sort of error partway through.
2917 */
2921 /* Prepare to scan pg_index for entries having indrelid = this rel. */
2923 Anum_pg_index_indrelid,
2932 {
2935 /* Add index's OID to result list in the proper order */
2938 /* Check to see if it is a unique, non-partial btree index on OID */
2945 }
2950 /* Now save a copy of the completed list in the relcache entry. */
2958 }
2960 /*
2961 * insert_ordered_oid
2962 * Insert a new Oid into a sorted list of Oids, preserving ordering
2963 *
2964 * Building the ordered list this way is O(N^2), but with a pretty small
2965 * constant, so for the number of entries we expect it will probably be
2966 * faster than trying to apply qsort(). Most tables don't have very many
2967 * indexes...
2968 */
2971 {
2974 /* Does the datum belong at the front? */
2977 /* No, so find the entry it belongs after */
2980 {
2987 }
2988 /* Insert datum into list after 'prev' */
2991 }
2993 /*
2994 * RelationSetIndexList -- externally force the index list contents
2995 *
2996 * This is used to temporarily override what we think the set of valid
2997 * indexes is (including the presence or absence of an OID index).
2998 * The forcing will be valid only until transaction commit or abort.
2999 *
3000 * This should only be applied to nailed relations, because in a non-nailed
3001 * relation the hacked index list could be lost at any time due to SI
3002 * messages. In practice it is only used on pg_class (see REINDEX).
3003 *
3004 * It is up to the caller to make sure the given list is correctly ordered.
3005 *
3006 * We deliberately do not change rd_indexattr here: even when operating
3007 * with a temporary partial index list, HOT-update decisions must be made
3008 * correctly with respect to the full index set. It is up to the caller
3009 * to ensure that a correct rd_indexattr set has been cached before first
3010 * calling RelationSetIndexList; else a subsequent inquiry might cause a
3011 * wrong rd_indexattr set to get computed and cached.
3012 */
3013 void
3015 {
3016 MemoryContext oldcxt;
3019 /* Copy the list into the cache context (could fail for lack of mem) */
3023 /* Okay to replace old list */
3028 /* must flag that we have a forced index list */
3030 }
3032 /*
3033 * RelationGetOidIndex -- get the pg_class OID of the relation's OID index
3034 *
3035 * Returns InvalidOid if there is no such index.
3036 */
3037 Oid
3039 {
3042 /*
3043 * If relation doesn't have OIDs at all, caller is probably confused. (We
3044 * could just silently return InvalidOid, but it seems better to throw an
3045 * assertion.)
3046 */
3050 {
3051 /* RelationGetIndexList does the heavy lifting. */
3055 }
3058 }
3060 /*
3061 * RelationGetIndexExpressions -- get the index expressions for an index
3062 *
3063 * We cache the result of transforming pg_index.indexprs into a node tree.
3064 * If the rel is not an index or has no expressional columns, we return NIL.
3065 * Otherwise, the returned tree is copied into the caller's memory context.
3066 * (We don't want to return a pointer to the relcache copy, since it could
3067 * disappear due to relcache invalidation.)
3068 */
3069 List *
3071 {
3073 Datum exprsDatum;
3076 MemoryContext oldcxt;
3078 /* Quick exit if we already computed the result. */
3082 /* Quick exit if there is nothing to do. */
3087 /*
3088 * We build the tree we intend to return in the caller's context. After
3089 * successfully completing the work, we copy it into the relcache entry.
3090 * This avoids problems if we get some sort of error partway through.
3091 */
3093 Anum_pg_index_indexprs,
3101 /*
3102 * Run the expressions through eval_const_expressions. This is not just an
3103 * optimization, but is necessary, because the planner will be comparing
3104 * them to similarly-processed qual clauses, and may fail to detect valid
3105 * matches without this. We don't bother with canonicalize_qual, however.
3106 */
3109 /*
3110 * Also mark any coercion format fields as "don't care", so that the
3111 * planner can match to both explicit and implicit coercions.
3112 */
3115 /* May as well fix opfuncids too */
3118 /* Now save a copy of the completed tree in the relcache entry. */
3124 }
3126 /*
3127 * RelationGetIndexPredicate -- get the index predicate for an index
3128 *
3129 * We cache the result of transforming pg_index.indpred into an implicit-AND
3130 * node tree (suitable for ExecQual).
3131 * If the rel is not an index or has no predicate, we return NIL.
3132 * Otherwise, the returned tree is copied into the caller's memory context.
3133 * (We don't want to return a pointer to the relcache copy, since it could
3134 * disappear due to relcache invalidation.)
3135 */
3136 List *
3138 {
3140 Datum predDatum;
3143 MemoryContext oldcxt;
3145 /* Quick exit if we already computed the result. */
3149 /* Quick exit if there is nothing to do. */
3154 /*
3155 * We build the tree we intend to return in the caller's context. After
3156 * successfully completing the work, we copy it into the relcache entry.
3157 * This avoids problems if we get some sort of error partway through.
3158 */
3160 Anum_pg_index_indpred,
3168 /*
3169 * Run the expression through const-simplification and canonicalization.
3170 * This is not just an optimization, but is necessary, because the planner
3171 * will be comparing it to similarly-processed qual clauses, and may fail
3172 * to detect valid matches without this. This must match the processing
3173 * done to qual clauses in preprocess_expression()! (We can skip the
3174 * stuff involving subqueries, however, since we don't allow any in index
3175 * predicates.)
3176 */
3181 /*
3182 * Also mark any coercion format fields as "don't care", so that the
3183 * planner can match to both explicit and implicit coercions.
3184 */
3187 /* Also convert to implicit-AND format */
3190 /* May as well fix opfuncids too */
3193 /* Now save a copy of the completed tree in the relcache entry. */
3199 }
3201 /*
3202 * RelationGetIndexAttrBitmap -- get a bitmap of index attribute numbers
3203 *
3204 * The result has a bit set for each attribute used anywhere in the index
3205 * definitions of all the indexes on this relation. (This includes not only
3206 * simple index keys, but attributes used in expressions and partial-index
3207 * predicates.)
3208 *
3209 * Attribute numbers are offset by FirstLowInvalidHeapAttributeNumber so that
3210 * we can include system attributes (e.g., OID) in the bitmap representation.
3211 *
3212 * The returned result is palloc'd in the caller's memory context and should
3213 * be bms_free'd when not needed anymore.
3214 */
3215 Bitmapset *
3217 {
3221 MemoryContext oldcxt;
3223 /* Quick exit if we already computed the result. */
3227 /* Fast path if definitely no indexes */
3231 /*
3232 * Get cached list of index OIDs
3233 */
3236 /* Fall out if no indexes (but relhasindex was set) */
3240 /*
3241 * For each index, add referenced attributes to indexattrs.
3242 */
3245 {
3247 Relation indexDesc;
3253 /* Extract index key information from the index's pg_index row */
3256 /* Collect simple attribute references */
3258 {
3264 }
3266 /* Collect all attributes used in expressions, too */
3269 /* Collect all attributes in the index predicate, too */
3273 }
3277 /* Now save a copy of the bitmap in the relcache entry. */
3282 /* We return our original working copy for caller to play with */
3284 }
3287 /*
3288 * load_relcache_init_file, write_relcache_init_file
3289 *
3290 * In late 1992, we started regularly having databases with more than
3291 * a thousand classes in them. With this number of classes, it became
3292 * critical to do indexed lookups on the system catalogs.
3293 *
3294 * Bootstrapping these lookups is very hard. We want to be able to
3295 * use an index on pg_attribute, for example, but in order to do so,
3296 * we must have read pg_attribute for the attributes in the index,
3297 * which implies that we need to use the index.
3298 *
3299 * In order to get around the problem, we do the following:
3300 *
3301 * + When the database system is initialized (at initdb time), we
3302 * don't use indexes. We do sequential scans.
3303 *
3304 * + When the backend is started up in normal mode, we load an image
3305 * of the appropriate relation descriptors, in internal format,
3306 * from an initialization file in the data/base/... directory.
3307 *
3308 * + If the initialization file isn't there, then we create the
3309 * relation descriptors using sequential scans and write 'em to
3310 * the initialization file for use by subsequent backends.
3311 *
3312 * We could dispense with the initialization file and just build the
3313 * critical reldescs the hard way on every backend startup, but that
3314 * slows down backend startup noticeably.
3315 *
3316 * We can in fact go further, and save more relcache entries than
3317 * just the ones that are absolutely critical; this allows us to speed
3318 * up backend startup by not having to build such entries the hard way.
3319 * Presently, all the catalog and index entries that are referred to
3320 * by catcaches are stored in the initialization file.
3321 *
3322 * The same mechanism that detects when catcache and relcache entries
3323 * need to be invalidated (due to catalog updates) also arranges to
3324 * unlink the initialization file when its contents may be out of date.
3325 * The file will then be rebuilt during the next backend startup.
3326 */
3328 /*
3329 * load_relcache_init_file -- attempt to load cache from the init file
3330 *
3331 * If successful, return TRUE and set criticalRelcachesBuilt to true.
3332 * If not successful, return FALSE.
3333 *
3334 * NOTE: we assume we are already switched into CacheMemoryContext.
3335 */
3336 static bool
3338 {
3343 num_rels,
3344 max_rels,
3345 nailed_rels,
3346 nailed_indexes,
3347 magic;
3357 /*
3358 * Read the index relcache entries from the file. Note we will not enter
3359 * any of them into the cache if the read fails partway through; this
3360 * helps to guard against broken init files.
3361 */
3368 /* check for correct magic number (compatible version) */
3375 {
3376 Size len;
3378 Relation rel;
3379 Form_pg_class relform;
3382 /* first read the relation descriptor length */
3384 {
3388 }
3390 /* safety check for incompatible relcache layout */
3394 /* allocate another relcache header */
3396 {
3399 }
3403 /* then, read the Relation structure */
3407 /* next read the relation tuple form */
3417 /* initialize attribute tuple forms */
3425 /* next read all the attribute tuple form data entries */
3428 {
3437 }
3439 /* next read the access method specific field */
3443 {
3449 }
3450 else
3451 {
3453 }
3455 /* mark not-null status */
3457 {
3462 }
3464 /* If it's an index, there's more to do */
3466 {
3467 Form_pg_am am;
3468 MemoryContext indexcxt;
3476 /* Count nailed indexes to ensure we have 'em all */
3478 nailed_indexes++;
3480 /* next, read the pg_index tuple */
3488 /* Fix up internal pointers in the tuple -- see heap_copytuple */
3492 /* next, read the access method tuple form */
3501 /*
3502 * prepare index info context --- parameters should match
3503 * RelationInitIndexAccessInfo
3504 */
3507 ALLOCSET_SMALL_MINSIZE,
3508 ALLOCSET_SMALL_INITSIZE,
3509 ALLOCSET_SMALL_MAXSIZE);
3512 /* next, read the vector of opfamily OIDs */
3522 /* next, read the vector of opcintype OIDs */
3532 /* next, read the vector of operator OIDs */
3542 /* next, read the vector of support procedures */
3551 /* finally, read the vector of indoption values */
3561 /* set up zeroed fmgr-info vectors */
3567 }
3568 else
3569 {
3570 /* Count nailed rels to ensure we have 'em all */
3572 nailed_rels++;
3585 }
3587 /*
3588 * Rules and triggers are not saved (mainly because the internal
3589 * format is complex and subject to change). They must be rebuilt if
3590 * needed by RelationCacheInitializePhase2. This is not expected to
3591 * be a big performance hit since few system catalogs have such. Ditto
3592 * for index expressions and predicates.
3593 */
3600 /*
3601 * Reset transient-state fields in the relcache entry
3602 */
3608 else
3619 /*
3620 * Recompute lock and physical addressing info. This is needed in
3621 * case the pg_internal.init file was copied from some other database
3622 * by CREATE DATABASE.
3623 */
3626 }
3628 /*
3629 * We reached the end of the init file without apparent problem. Did we
3630 * get the right number of nailed items? (This is a useful crosscheck in
3631 * case the set of critical rels or indexes changes.)
3632 */
3637 /*
3638 * OK, all appears well.
3639 *
3640 * Now insert all the new relcache entries into the cache.
3641 */
3643 {
3645 /* also make a list of their OIDs, for RelationIdIsInInitFile */
3647 initFileRelationIds);
3648 }
3656 /*
3657 * init file is broken, so do it the hard way. We don't bother trying to
3658 * free the clutter we just allocated; it's not in the relcache so it
3659 * won't hurt.
3660 */
3661 read_failed:
3666 }
3668 /*
3669 * Write out a new initialization file with the current contents
3670 * of the relcache.
3671 */
3672 static void
3674 {
3679 HASH_SEQ_STATUS status;
3681 MemoryContext oldcxt;
3684 /*
3685 * We must write a temporary file and rename it into place. Otherwise,
3686 * another backend starting at about the same time might crash trying to
3687 * read the partially-complete file.
3688 */
3698 {
3699 /*
3700 * We used to consider this a fatal error, but we might as well
3701 * continue with backend startup ...
3702 */
3706 tempfilename),
3709 }
3711 /*
3712 * Write a magic number to serve as a file version identifier. We can
3713 * change the magic number whenever the relcache layout changes.
3714 */
3719 /*
3720 * Write all the reldescs (in no particular order).
3721 */
3727 {
3731 /* first write the relcache entry proper */
3734 /* next write the relation tuple form */
3737 /* next, do all the attribute tuple form data entries */
3739 {
3741 }
3743 /* next, do the access method specific field */
3746 fp);
3748 /* If it's an index, there's more to do */
3750 {
3753 /* write the pg_index tuple */
3754 /* we assume this was created by heap_copytuple! */
3757 fp);
3759 /* next, write the access method tuple form */
3762 /* next, write the vector of opfamily OIDs */
3765 fp);
3767 /* next, write the vector of opcintype OIDs */
3770 fp);
3772 /* next, write the vector of operator OIDs */
3775 fp);
3777 /* next, write the vector of support procedures */
3780 fp);
3782 /* finally, write the vector of indoption values */
3785 fp);
3786 }
3788 /* also make a list of their OIDs, for RelationIdIsInInitFile */
3791 initFileRelationIds);
3793 }
3798 /*
3799 * Now we have to check whether the data we've so painstakingly
3800 * accumulated is already obsolete due to someone else's just-committed
3801 * catalog changes. If so, we just delete the temp file and leave it to
3802 * the next backend to try again. (Our own relcache entries will be
3803 * updated by SI message processing, but we can't be sure whether what we
3804 * wrote out was up-to-date.)
3805 *
3806 * This mustn't run concurrently with RelationCacheInitFileInvalidate, so
3807 * grab a serialization lock for the duration.
3808 */
3811 /* Make sure we have seen all incoming SI messages */
3814 /*
3815 * If we have received any SI relcache invals since backend start, assume
3816 * we may have written out-of-date data.
3817 */
3819 {
3820 /*
3821 * OK, rename the temp file to its final name, deleting any
3822 * previously-existing init file.
3823 *
3824 * Note: a failure here is possible under Cygwin, if some other
3825 * backend is holding open an unlinked-but-not-yet-gone init file. So
3826 * treat this as a noncritical failure; just remove the useless temp
3827 * file on failure.
3828 */
3831 }
3832 else
3833 {
3834 /* Delete the already-obsolete temp file */
3836 }
3839 }
3841 /* write a chunk of data preceded by its length */
3842 static void
3844 {
3849 }
3851 /*
3852 * Detect whether a given relation (identified by OID) is one of the ones
3853 * we store in the init file.
3854 *
3855 * Note that we effectively assume that all backends running in a database
3856 * would choose to store the same set of relations in the init file;
3857 * otherwise there are cases where we'd fail to detect the need for an init
3858 * file invalidation. This does not seem likely to be a problem in practice.
3859 */
3860 bool
3862 {
3864 }
3866 /*
3867 * Invalidate (remove) the init file during commit of a transaction that
3868 * changed one or more of the relation cache entries that are kept in the
3869 * init file.
3870 *
3871 * We actually need to remove the init file twice: once just before sending
3872 * the SI messages that include relcache inval for such relations, and once
3873 * just after sending them. The unlink before ensures that a backend that's
3874 * currently starting cannot read the now-obsolete init file and then miss
3875 * the SI messages that will force it to update its relcache entries. (This
3876 * works because the backend startup sequence gets into the PGPROC array before
3877 * trying to load the init file.) The unlink after is to synchronize with a
3878 * backend that may currently be trying to write an init file based on data
3879 * that we've just rendered invalid. Such a backend will see the SI messages,
3880 * but we can't leave the init file sitting around to fool later backends.
3881 *
3882 * Ignore any failure to unlink the file, since it might not be there if
3883 * no backend has been started since the last removal.
3884 */
3885 void
3887 {
3894 {
3895 /* no interlock needed here */
3897 }
3898 else
3899 {
3900 /*
3901 * We need to interlock this against write_relcache_init_file, to
3902 * guard against possibility that someone renames a new-but-
3903 * already-obsolete init file into place just after we unlink. With
3904 * the interlock, it's certain that write_relcache_init_file will
3905 * notice our SI inval message before renaming into place, or else
3906 * that we will execute second and successfully unlink the file.
3907 */
3911 }
3912 }
3914 /*
3915 * Remove the init file for a given database during postmaster startup.
3916 *
3917 * We used to keep the init file across restarts, but that is unsafe in PITR
3918 * scenarios, and even in simple crash-recovery cases there are windows for
3919 * the init file to become out-of-sync with the database. So now we just
3920 * remove it during startup and expect the first backend launch to rebuild it.
3921 * Of course, this has to happen in each database of the cluster. For
3922 * simplicity this is driven by flatfiles.c, which has to scan pg_database
3923 * anyway.
3924 */
3925 void
3927 {
3933 /* ignore any error, since it might not be there at all */
3934 }