| blob | 29976e78b46f611dab3a88b17ace0a4871171ab7 |
1 /*-------------------------------------------------------------------------
2 *
3 * relcache.c
4 * POSTGRES relation descriptor cache code
5 *
6 * Portions Copyright (c) 1996-2009, 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 */
310 /* make sure relation is marked as having no open file yet */
313 /*
314 * Copy the relation tuple form
315 *
316 * We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE. The
317 * variable-length fields (relacl, reloptions) are NOT stored in the
318 * relcache --- there'd be little point in it, since we don't copy the
319 * tuple's nulls bitmap and hence wouldn't know if the values are valid.
320 * Bottom line is that relacl *cannot* be retrieved from the relcache. Get
321 * it from the syscache if you need it. The same goes for the original
322 * form of reloptions (however, we do store the parsed form of reloptions
323 * in rd_options).
324 */
329 /* initialize relation tuple form */
332 /* and allocate attribute tuple form storage */
335 /* which we mark as a reference-counted tupdesc */
341 }
343 /*
344 * RelationParseRelOptions
345 * Convert pg_class.reloptions into pre-parsed rd_options
346 *
347 * tuple is the real pg_class tuple (not rd_rel!) for relation
348 *
349 * Note: rd_rel and (if an index) rd_am must be valid already
350 */
351 static void
353 {
358 /* Fall out if relkind should not have options */
360 {
368 }
370 /*
371 * Fetch reloptions from tuple; have to use a hardwired descriptor because
372 * we might not have any other for pg_class yet (consider executing this
373 * code for pg_class itself)
374 */
380 /* Copy parsed data into CacheMemoryContext */
382 {
386 }
387 }
389 /*
390 * RelationBuildTupleDesc
391 *
392 * Form the relation's tuple descriptor from information in
393 * the pg_attribute, pg_attrdef & pg_constraint system catalogs.
394 */
395 static void
397 {
398 HeapTuple pg_attribute_tuple;
399 Relation pg_attribute_desc;
400 SysScanDesc pg_attribute_scan;
407 /* copy some fields from pg_class row to rd_att */
416 /*
417 * Form a scan key that selects only user attributes (attnum > 0).
418 * (Eliminating system attribute rows at the index level is lots faster
419 * than fetching them.)
420 */
422 Anum_pg_attribute_attrelid,
426 Anum_pg_attribute_attnum,
430 /*
431 * Open pg_attribute and begin a scan. Force heap scan if we haven't yet
432 * built the critical relcache entries (this includes initdb and startup
433 * without a pg_internal.init file).
434 */
437 AttributeRelidNumIndexId,
438 criticalRelcachesBuilt,
439 SnapshotNow,
442 /*
443 * add attribute data to relation->rd_att
444 */
448 {
449 Form_pg_attribute attp;
459 attp,
460 ATTRIBUTE_FIXED_PART_SIZE);
462 /* Update constraint/default info */
467 {
475 ndef++;
476 }
477 need--;
480 }
482 /*
483 * end the scan and close the attribute relation
484 */
492 /*
493 * The attcacheoff values we read from pg_attribute should all be -1
494 * ("unknown"). Verify this if assert checking is on. They will be
495 * computed when and if needed during tuple access.
496 */
497 #ifdef USE_ASSERT_CHECKING
498 {
503 }
504 #endif
506 /*
507 * However, we can easily set the attcacheoff value for the first
508 * attribute: it must be zero. This eliminates the need for special cases
509 * for attnum=1 that used to exist in fastgetattr() and index_getattr().
510 */
514 /*
515 * Set up constraint/default info
516 */
518 {
522 {
526 else
530 }
531 else
535 {
541 }
542 else
544 }
545 else
546 {
549 }
550 }
552 /*
553 * RelationBuildRuleLock
554 *
555 * Form the relation's rewrite rules from information in
556 * the pg_rewrite system catalog.
557 *
558 * Note: The rule parsetrees are potentially very complex node structures.
559 * To allow these trees to be freed when the relcache entry is flushed,
560 * we make a private memory context to hold the RuleLock information for
561 * each relcache entry that has associated rules. The context is used
562 * just for rule info, not for any other subsidiary data of the relcache
563 * entry, because that keeps the update logic in RelationClearRelation()
564 * manageable. The other subsidiary data structures are simple enough
565 * to be easy to free explicitly, anyway.
566 */
567 static void
569 {
570 MemoryContext rulescxt;
571 MemoryContext oldcxt;
572 HeapTuple rewrite_tuple;
573 Relation rewrite_desc;
574 TupleDesc rewrite_tupdesc;
575 SysScanDesc rewrite_scan;
576 ScanKeyData key;
582 /*
583 * Make the private context. Parameters are set on the assumption that
584 * it'll probably not contain much data.
585 */
588 ALLOCSET_SMALL_MINSIZE,
589 ALLOCSET_SMALL_INITSIZE,
590 ALLOCSET_SMALL_MAXSIZE);
593 /*
594 * allocate an array to hold the rewrite rules (the array is extended if
595 * necessary)
596 */
602 /*
603 * form a scan key
604 */
606 Anum_pg_rewrite_ev_class,
610 /*
611 * open pg_rewrite and begin a scan
612 *
613 * Note: since we scan the rules using RewriteRelRulenameIndexId, we will
614 * be reading the rules in name order, except possibly during
615 * emergency-recovery operations (ie, IgnoreSystemIndexes). This in turn
616 * ensures that rules will be fired in name order.
617 */
621 RewriteRelRulenameIndexId,
626 {
629 Datum rule_datum;
643 /*
644 * Must use heap_getattr to fetch ev_action and ev_qual. Also, the
645 * rule strings are often large enough to be toasted. To avoid
646 * leaking memory in the caller's context, do the detoasting here so
647 * we can free the detoasted version.
648 */
650 Anum_pg_rewrite_ev_action,
651 rewrite_tupdesc,
661 Anum_pg_rewrite_ev_qual,
662 rewrite_tupdesc,
671 /*
672 * We want the rule's table references to be checked as though by the
673 * table owner, not the user referencing the rule. Therefore, scan
674 * through the rule's actions and set the checkAsUser field on all
675 * rtable entries. We have to look at the qual as well, in case it
676 * contains sublinks.
677 *
678 * The reason for doing this when the rule is loaded, rather than when
679 * it is stored, is that otherwise ALTER TABLE OWNER would have to
680 * grovel through stored rules to update checkAsUser fields. Scanning
681 * the rule tree during load is relatively cheap (compared to
682 * constructing it in the first place), so we do it here.
683 */
688 {
692 }
694 }
696 /*
697 * end the scan and close the attribute relation
698 */
702 /*
703 * there might not be any rules (if relhasrules is out-of-date)
704 */
706 {
711 }
713 /*
714 * form a RuleLock and insert into relation
715 */
721 }
723 /*
724 * equalRuleLocks
725 *
726 * Determine whether two RuleLocks are equivalent
727 *
728 * Probably this should be in the rules code someplace...
729 */
730 static bool
732 {
735 /*
736 * As of 7.3 we assume the rule ordering is repeatable, because
737 * RelationBuildRuleLock should read 'em in a consistent order. So just
738 * compare corresponding slots.
739 */
741 {
747 {
765 }
766 }
770 }
773 /*
774 * RelationBuildDesc
775 *
776 * Build a relation descriptor --- either a new one, or by
777 * recycling the given old relation object. The latter case
778 * supports rebuilding a relcache entry without invalidating
779 * pointers to it. The caller must hold at least
780 * AccessShareLock on the target relid.
781 *
782 * Returns NULL if no pg_class row could be found for the given relid
783 * (suggesting we are trying to access a just-deleted relation).
784 * Any other error is reported via elog.
785 */
786 static Relation
788 {
789 Relation relation;
790 Oid relid;
791 HeapTuple pg_class_tuple;
792 Form_pg_class relp;
793 MemoryContext oldcxt;
795 /*
796 * find the tuple in pg_class corresponding to the given relation id
797 */
800 /*
801 * if no such tuple exists, return NULL
802 */
806 /*
807 * get information from the pg_class_tuple
808 */
812 /*
813 * allocate storage for the relation descriptor, and copy pg_class_tuple
814 * to relation->rd_rel.
815 */
818 /*
819 * initialize the relation's relation id (relation->rd_id)
820 */
823 /*
824 * normal relations are not nailed into the cache; nor can a pre-existing
825 * relation be new. It could be temp though. (Actually, it could be new
826 * too, but it's okay to forget that fact if forced to flush the entry.)
827 */
835 else
838 /*
839 * initialize the tuple descriptor (relation->rd_att).
840 */
843 /*
844 * Fetch rules and triggers that affect this relation
845 */
848 else
849 {
852 }
856 else
859 /*
860 * if it's an index, initialize index-related information
861 */
865 /* extract reloptions if any */
868 /*
869 * initialize the relation lock manager information
870 */
873 /*
874 * initialize physical addressing information for the relation
875 */
878 /* make sure relation is marked as having no open file yet */
881 /*
882 * now we can free the memory allocated for pg_class_tuple
883 */
886 /*
887 * Insert newly created relation into relcache hash tables.
888 */
893 /* It's fully valid */
897 }
899 /*
900 * Initialize the physical addressing info (RelFileNode) for a relcache entry
901 */
902 static void
904 {
907 else
911 else
914 }
916 /*
917 * Initialize index-access-method support data for an index relation
918 */
919 void
921 {
922 HeapTuple tuple;
923 Form_pg_am aform;
924 Datum indclassDatum;
925 Datum indoptionDatum;
929 MemoryContext indexcxt;
930 MemoryContext oldcontext;
932 uint16 amstrategies;
933 uint16 amsupport;
935 /*
936 * Make a copy of the pg_index entry for the index. Since pg_index
937 * contains variable-length and possibly-null fields, we have to do this
938 * honestly rather than just treating it as a Form_pg_index struct.
939 */
952 /*
953 * Make a copy of the pg_am entry for the index's access method
954 */
973 /*
974 * Make the private context to hold index access info. The reason we need
975 * a context, and not just a couple of pallocs, is so that we won't leak
976 * any subsidiary info attached to fmgr lookup records.
977 *
978 * Context parameters are set on the assumption that it'll probably not
979 * contain much data.
980 */
983 ALLOCSET_SMALL_MINSIZE,
984 ALLOCSET_SMALL_INITSIZE,
985 ALLOCSET_SMALL_MAXSIZE);
988 /*
989 * Allocate arrays to hold data
990 */
1003 else
1007 {
1014 }
1015 else
1016 {
1019 }
1024 /*
1025 * indclass cannot be referenced directly through the C struct, because it
1026 * comes after the variable-width indkey field. Must extract the datum
1027 * the hard way...
1028 */
1030 Anum_pg_index_indclass,
1036 /*
1037 * Fill the operator and support procedure OID arrays, as well as the info
1038 * about opfamilies and opclass input types. (aminfo and supportinfo are
1039 * left as zeroes, and are filled on-the-fly when used)
1040 */
1046 /*
1047 * Similarly extract indoption and copy it to the cache entry
1048 */
1050 Anum_pg_index_indoption,
1057 /*
1058 * expressions and predicate cache will be filled later
1059 */
1063 }
1065 /*
1066 * IndexSupportInitialize
1067 * Initializes an index's cached opclass information,
1068 * given the index's pg_index.indclass entry.
1069 *
1070 * Data is returned into *indexOperator, *indexSupport, *opFamily, and
1071 * *opcInType, which are arrays allocated by the caller.
1072 *
1073 * The caller also passes maxStrategyNumber, maxSupportNumber, and
1074 * maxAttributeNumber, since these indicate the size of the arrays
1075 * it has allocated --- but in practice these numbers must always match
1076 * those obtainable from the system catalog entries for the index and
1077 * access method.
1078 */
1079 static void
1085 StrategyNumber maxStrategyNumber,
1086 StrategyNumber maxSupportNumber,
1087 AttrNumber maxAttributeNumber)
1088 {
1092 {
1098 /* look up the info for this opclass, using a cache */
1100 maxStrategyNumber,
1101 maxSupportNumber);
1103 /* copy cached data into relcache entry */
1114 }
1115 }
1117 /*
1118 * LookupOpclassInfo
1119 *
1120 * This routine maintains a per-opclass cache of the information needed
1121 * by IndexSupportInitialize(). This is more efficient than relying on
1122 * the catalog cache, because we can load all the info about a particular
1123 * opclass in a single indexscan of pg_amproc or pg_amop.
1124 *
1125 * The information from pg_am about expected range of strategy and support
1126 * numbers is passed in, rather than being looked up, mainly because the
1127 * caller will have it already.
1128 *
1129 * Note there is no provision for flushing the cache. This is OK at the
1130 * moment because there is no way to ALTER any interesting properties of an
1131 * existing opclass --- all you can do is drop it, which will result in
1132 * a useless but harmless dead entry in the cache. To support altering
1133 * opclass membership (not the same as opfamily membership!), we'd need to
1134 * be able to flush this cache as well as the contents of relcache entries
1135 * for indexes.
1136 */
1139 StrategyNumber numStrats,
1140 StrategyNumber numSupport)
1141 {
1144 Relation rel;
1145 SysScanDesc scan;
1147 HeapTuple htup;
1151 {
1152 /* First time through: initialize the opclass cache */
1153 HASHCTL ctl;
1164 }
1171 {
1172 /* Need to allocate memory for new entry */
1181 else
1188 else
1190 }
1191 else
1192 {
1195 }
1197 /*
1198 * When testing for cache-flush hazards, we intentionally disable the
1199 * operator class cache and force reloading of the info on each call. This
1200 * is helpful because we want to test the case where a cache flush occurs
1201 * while we are loading the info, and it's very hard to provoke that if
1202 * this happens only once per opclass per backend.
1203 */
1204 #if defined(CLOBBER_CACHE_ALWAYS)
1206 #endif
1211 /*
1212 * Need to fill in new entry.
1213 *
1214 * To avoid infinite recursion during startup, force heap scans if we're
1215 * looking up info for the opclasses used by the indexes we would like to
1216 * reference here.
1217 */
1222 /*
1223 * We have to fetch the pg_opclass row to determine its opfamily and
1224 * opcintype, which are needed to look up the operators and functions.
1225 * It'd be convenient to use the syscache here, but that probably doesn't
1226 * work while bootstrapping.
1227 */
1229 ObjectIdAttributeNumber,
1237 {
1242 }
1243 else
1250 /*
1251 * Scan pg_amop to obtain operators for the opclass. We only fetch the
1252 * default ones (those with lefttype = righttype = opcintype).
1253 */
1255 {
1257 Anum_pg_amop_amopfamily,
1261 Anum_pg_amop_amoplefttype,
1265 Anum_pg_amop_amoprighttype,
1273 {
1282 }
1286 }
1288 /*
1289 * Scan pg_amproc to obtain support procs for the opclass. We only fetch
1290 * the default ones (those with lefttype = righttype = opcintype).
1291 */
1293 {
1295 Anum_pg_amproc_amprocfamily,
1299 Anum_pg_amproc_amproclefttype,
1303 Anum_pg_amproc_amprocrighttype,
1311 {
1321 }
1325 }
1329 }
1332 /*
1333 * formrdesc
1334 *
1335 * This is a special cut-down version of RelationBuildDesc()
1336 * used by RelationCacheInitializePhase2() in initializing the relcache.
1337 * The relation descriptor is built just from the supplied parameters,
1338 * without actually looking at any system table entries. We cheat
1339 * quite a lot since we only need to work for a few basic system
1340 * catalogs.
1341 *
1342 * formrdesc is currently used for: pg_class, pg_attribute, pg_proc,
1343 * and pg_type (see RelationCacheInitializePhase2).
1344 *
1345 * Note that these catalogs can't have constraints (except attnotnull),
1346 * default values, rules, or triggers, since we don't cope with any of that.
1347 *
1348 * NOTE: we assume we are already switched into CacheMemoryContext.
1349 */
1350 static void
1353 {
1354 Relation relation;
1358 /*
1359 * allocate new relation desc, clear all fields of reldesc
1360 */
1366 /* make sure relation is marked as having no open file yet */
1369 /*
1370 * initialize reference count: 1 because it is nailed in cache
1371 */
1374 /*
1375 * all entries built with this routine are nailed-in-cache; none are for
1376 * new or temp relations.
1377 */
1384 /*
1385 * initialize relation tuple form
1386 *
1387 * The data we insert here is pretty incomplete/bogus, but it'll serve to
1388 * get us launched. RelationCacheInitializePhase2() will read the real
1389 * data from pg_class and replace what we've done here.
1390 */
1397 /*
1398 * It's important to distinguish between shared and non-shared relations,
1399 * even at bootstrap time, to make sure we know where they are stored. At
1400 * present, all relations that formrdesc is used for are not shared.
1401 */
1404 /*
1405 * Likewise, we must know if a relation is temp ... but formrdesc is not
1406 * used for any temp relations.
1407 */
1416 /*
1417 * initialize attribute tuple form
1418 *
1419 * Unlike the case with the relation tuple, this data had better be right
1420 * because it will never be replaced. The input values must be correctly
1421 * defined by macros in src/include/catalog/ headers.
1422 */
1429 /*
1430 * initialize tuple desc info
1431 */
1434 {
1437 ATTRIBUTE_FIXED_PART_SIZE);
1439 /* make sure attcacheoff is valid */
1441 }
1443 /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
1446 /* mark not-null status */
1448 {
1453 }
1455 /*
1456 * initialize relation id from info in att array (my, this is ugly)
1457 */
1461 /*
1462 * initialize the relation lock manager information
1463 */
1466 /*
1467 * initialize physical addressing information for the relation
1468 */
1471 /*
1472 * initialize the rel-has-index flag, using hardwired knowledge
1473 */
1475 {
1476 /* In bootstrap mode, we have no indexes */
1478 }
1479 else
1480 {
1481 /* Otherwise, all the rels formrdesc is used for have indexes */
1483 }
1485 /*
1486 * add new reldesc to relcache
1487 */
1490 /* It's fully valid */
1492 }
1495 /* ----------------------------------------------------------------
1496 * Relation Descriptor Lookup Interface
1497 * ----------------------------------------------------------------
1498 */
1500 /*
1501 * RelationIdGetRelation
1502 *
1503 * Lookup a reldesc by OID; make one if not already in cache.
1504 *
1505 * Returns NULL if no pg_class row could be found for the given relid
1506 * (suggesting we are trying to access a just-deleted relation).
1507 * Any other error is reported via elog.
1508 *
1509 * NB: caller should already have at least AccessShareLock on the
1510 * relation ID, else there are nasty race conditions.
1511 *
1512 * NB: relation ref count is incremented, or set to 1 if new entry.
1513 * Caller should eventually decrement count. (Usually,
1514 * that happens by calling RelationClose().)
1515 */
1516 Relation
1518 {
1519 Relation rd;
1521 /*
1522 * first try to find reldesc in the cache
1523 */
1527 {
1529 /* revalidate nailed index if necessary */
1533 }
1535 /*
1536 * no reldesc in the cache, so have RelationBuildDesc() build one and add
1537 * it.
1538 */
1543 }
1545 /* ----------------------------------------------------------------
1546 * cache invalidation support routines
1547 * ----------------------------------------------------------------
1548 */
1550 /*
1551 * RelationIncrementReferenceCount
1552 * Increments relation reference count.
1553 *
1554 * Note: bootstrap mode has its own weird ideas about relation refcount
1555 * behavior; we ought to fix it someday, but for now, just disable
1556 * reference count ownership tracking in bootstrap mode.
1557 */
1558 void
1560 {
1565 }
1567 /*
1568 * RelationDecrementReferenceCount
1569 * Decrements relation reference count.
1570 */
1571 void
1573 {
1578 }
1580 /*
1581 * RelationClose - close an open relation
1582 *
1583 * Actually, we just decrement the refcount.
1584 *
1585 * NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries
1586 * will be freed as soon as their refcount goes to zero. In combination
1587 * with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
1588 * to catch references to already-released relcache entries. It slows
1589 * things down quite a bit, however.
1590 */
1591 void
1593 {
1594 /* Note: no locking manipulations needed */
1597 #ifdef RELCACHE_FORCE_RELEASE
1602 #endif
1603 }
1605 /*
1606 * RelationReloadIndexInfo - reload minimal information for an open index
1607 *
1608 * This function is used only for indexes. A relcache inval on an index
1609 * can mean that its pg_class or pg_index row changed. There are only
1610 * very limited changes that are allowed to an existing index's schema,
1611 * so we can update the relcache entry without a complete rebuild; which
1612 * is fortunate because we can't rebuild an index entry that is "nailed"
1613 * and/or in active use. We support full replacement of the pg_class row,
1614 * as well as updates of a few simple fields of the pg_index row.
1615 *
1616 * We can't necessarily reread the catalog rows right away; we might be
1617 * in a failed transaction when we receive the SI notification. If so,
1618 * RelationClearRelation just marks the entry as invalid by setting
1619 * rd_isvalid to false. This routine is called to fix the entry when it
1620 * is next needed.
1621 *
1622 * We assume that at the time we are called, we have at least AccessShareLock
1623 * on the target index. (Note: in the calls from RelationClearRelation,
1624 * this is legitimate because we know the rel has positive refcount.)
1625 */
1626 static void
1628 {
1630 HeapTuple pg_class_tuple;
1631 Form_pg_class relp;
1633 /* Should be called only for invalidated indexes */
1636 /* Should be closed at smgr level */
1639 /*
1640 * Read the pg_class row
1641 *
1642 * Don't try to use an indexscan of pg_class_oid_index to reload the info
1643 * for pg_class_oid_index ...
1644 */
1652 /* Reload reloptions in case they changed */
1656 /* done with pg_class tuple */
1658 /* We must recalculate physical address in case it changed */
1661 /*
1662 * Must reset targblock, fsm_nblocks and vm_nblocks in case rel was
1663 * truncated
1664 */
1668 /* Must free any AM cached data, too */
1673 /*
1674 * For a non-system index, there are fields of the pg_index row that are
1675 * allowed to change, so re-read that row and update the relcache entry.
1676 * Most of the info derived from pg_index (such as support function lookup
1677 * info) cannot change, and indeed the whole point of this routine is to
1678 * update the relcache entry without clobbering that data; so wholesale
1679 * replacement is not appropriate.
1680 */
1682 {
1683 HeapTuple tuple;
1684 Form_pg_index index;
1701 }
1703 /* Okay, now it's valid again */
1705 }
1707 /*
1708 * RelationClearRelation
1709 *
1710 * Physically blow away a relation cache entry, or reset it and rebuild
1711 * it from scratch (that is, from catalog entries). The latter path is
1712 * usually used when we are notified of a change to an open relation
1713 * (one with refcount > 0). However, this routine just does whichever
1714 * it's told to do; callers must determine which they want.
1715 *
1716 * NB: when rebuilding, we'd better hold some lock on the relation.
1717 * In current usages this is presumed true because it has refcnt > 0.
1718 */
1719 static void
1721 {
1723 MemoryContext oldcxt;
1725 /*
1726 * Make sure smgr and lower levels close the relation's files, if they
1727 * weren't closed already. If the relation is not getting deleted, the
1728 * next smgr access should reopen the files automatically. This ensures
1729 * that the low-level file access state is updated after, say, a vacuum
1730 * truncation.
1731 */
1734 /*
1735 * Never, never ever blow away a nailed-in system relation, because we'd
1736 * be unable to recover. However, we must reset rd_targblock, in case we
1737 * got called because of a relation cache flush that was triggered by
1738 * VACUUM.
1739 *
1740 * If it's a nailed index, then we need to re-read the pg_class row to see
1741 * if its relfilenode changed. We can't necessarily do that here, because
1742 * we might be in a failed transaction. We assume it's okay to do it if
1743 * there are open references to the relcache entry (cf notes for
1744 * AtEOXact_RelationCache). Otherwise just mark the entry as possibly
1745 * invalid, and it'll be fixed when next opened.
1746 */
1748 {
1753 {
1757 }
1759 }
1761 /*
1762 * Even non-system indexes should not be blown away if they are open and
1763 * have valid index support information. This avoids problems with active
1764 * use of the index support information. As with nailed indexes, we
1765 * re-read the pg_class row to handle possible physical relocation of the
1766 * index, and we check for pg_index updates too.
1767 */
1771 {
1775 }
1777 /*
1778 * Remove relation from hash tables
1779 *
1780 * Note: we might be reinserting it momentarily, but we must not have it
1781 * visible in the hash tables until it's valid again, so don't try to
1782 * optimize this away...
1783 */
1788 /* Clear out catcache's entries for this relation */
1791 /*
1792 * Free all the subsidiary data structures of the relcache entry. We
1793 * cannot free rd_att if we are trying to rebuild the entry, however,
1794 * because pointers to it may be cached in various places. The rule
1795 * manager might also have pointers into the rewrite rules. So to begin
1796 * with, we can only get rid of these fields:
1797 */
1812 /*
1813 * If we're really done with the relcache entry, blow it away. But if
1814 * someone is still using it, reconstruct the whole deal without moving
1815 * the physical RelationData record (so that the someone's pointer is
1816 * still valid).
1817 */
1819 {
1820 /* ok to zap remaining substructure */
1822 /* can't use DecrTupleDescRefCount here */
1829 }
1830 else
1831 {
1832 /*
1833 * When rebuilding an open relcache entry, must preserve ref count and
1834 * rd_createSubid/rd_newRelfilenodeSubid state. Also attempt to
1835 * preserve the tupledesc and rewrite-rule substructures in place.
1836 * (Note: the refcount mechanism for tupledescs may eventually ensure
1837 * that we don't really need to preserve the tupledesc in-place, but
1838 * for now there are still a lot of places that assume an open rel's
1839 * tupledesc won't move.)
1840 *
1841 * Note that this process does not touch CurrentResourceOwner; which
1842 * is good because whatever ref counts the entry may have do not
1843 * necessarily belong to that resource owner.
1844 */
1855 {
1856 /* Should only get here if relation was deleted */
1865 }
1872 {
1873 /* needn't flush typcache here */
1878 }
1879 else
1880 {
1885 }
1887 {
1892 }
1893 else
1894 {
1897 }
1898 }
1899 }
1901 /*
1902 * RelationFlushRelation
1903 *
1904 * Rebuild the relation if it is open (refcount > 0), else blow it away.
1905 */
1906 static void
1908 {
1913 {
1914 /*
1915 * New relcache entries are always rebuilt, not flushed; else we'd
1916 * forget the "new" status of the relation, which is a useful
1917 * optimization to have. Ditto for the new-relfilenode status.
1918 */
1920 }
1921 else
1922 {
1923 /*
1924 * Pre-existing rels can be dropped from the relcache if not open.
1925 */
1927 }
1930 }
1932 /*
1933 * RelationForgetRelation - unconditionally remove a relcache entry
1934 *
1935 * External interface for destroying a relcache entry when we
1936 * drop the relation.
1937 */
1938 void
1940 {
1941 Relation relation;
1951 /* Unconditionally destroy the relcache entry */
1953 }
1955 /*
1956 * RelationCacheInvalidateEntry
1957 *
1958 * This routine is invoked for SI cache flush messages.
1959 *
1960 * Any relcache entry matching the relid must be flushed. (Note: caller has
1961 * already determined that the relid belongs to our database or is a shared
1962 * relation.)
1963 *
1964 * We used to skip local relations, on the grounds that they could
1965 * not be targets of cross-backend SI update messages; but it seems
1966 * safer to process them, so that our *own* SI update messages will
1967 * have the same effects during CommandCounterIncrement for both
1968 * local and nonlocal relations.
1969 */
1970 void
1972 {
1973 Relation relation;
1978 {
1979 relcacheInvalsReceived++;
1981 }
1982 }
1984 /*
1985 * RelationCacheInvalidate
1986 * Blow away cached relation descriptors that have zero reference counts,
1987 * and rebuild those with positive reference counts. Also reset the smgr
1988 * relation cache.
1989 *
1990 * This is currently used only to recover from SI message buffer overflow,
1991 * so we do not touch new-in-transaction relations; they cannot be targets
1992 * of cross-backend SI updates (and our own updates now go through a
1993 * separate linked list that isn't limited by the SI message buffer size).
1994 * Likewise, we need not discard new-relfilenode-in-transaction hints,
1995 * since any invalidation of those would be a local event.
1996 *
1997 * We do this in two phases: the first pass deletes deletable items, and
1998 * the second one rebuilds the rebuildable items. This is essential for
1999 * safety, because hash_seq_search only copes with concurrent deletion of
2000 * the element it is currently visiting. If a second SI overflow were to
2001 * occur while we are walking the table, resulting in recursive entry to
2002 * this routine, we could crash because the inner invocation blows away
2003 * the entry next to be visited by the outer scan. But this way is OK,
2004 * because (a) during the first pass we won't process any more SI messages,
2005 * so hash_seq_search will complete safely; (b) during the second pass we
2006 * only hold onto pointers to nondeletable entries.
2007 *
2008 * The two-phase approach also makes it easy to ensure that we process
2009 * nailed-in-cache indexes before other nondeletable items, and that we
2010 * process pg_class_oid_index first of all. In scenarios where a nailed
2011 * index has been given a new relfilenode, we have to detect that update
2012 * before the nailed index is used in reloading any other relcache entry.
2013 */
2014 void
2016 {
2017 HASH_SEQ_STATUS status;
2019 Relation relation;
2024 /* Phase 1 */
2028 {
2031 /* Must close all smgr references to avoid leaving dangling ptrs */
2034 /* Ignore new relations, since they are never SI targets */
2038 relcacheInvalsReceived++;
2041 {
2042 /* Delete this entry immediately */
2045 }
2046 else
2047 {
2048 /*
2049 * Add this entry to list of stuff to rebuild in second pass.
2050 * pg_class_oid_index goes on the front of rebuildFirstList, other
2051 * nailed indexes on the back, and everything else into
2052 * rebuildList (in no particular order).
2053 */
2056 {
2059 else
2061 }
2062 else
2064 }
2065 }
2067 /*
2068 * Now zap any remaining smgr cache entries. This must happen before we
2069 * start to rebuild entries, since that may involve catalog fetches which
2070 * will re-open catalog files.
2071 */
2074 /* Phase 2: rebuild the items found to need rebuild in phase 1 */
2076 {
2079 }
2082 {
2085 }
2087 }
2089 /*
2090 * AtEOXact_RelationCache
2091 *
2092 * Clean up the relcache at main-transaction commit or abort.
2093 *
2094 * Note: this must be called *before* processing invalidation messages.
2095 * In the case of abort, we don't want to try to rebuild any invalidated
2096 * cache entries (since we can't safely do database accesses). Therefore
2097 * we must reset refcnts before handling pending invalidations.
2098 *
2099 * As of PostgreSQL 8.1, relcache refcnts should get released by the
2100 * ResourceOwner mechanism. This routine just does a debugging
2101 * cross-check that no pins remain. However, we also need to do special
2102 * cleanup when the current transaction created any relations or made use
2103 * of forced index lists.
2104 */
2105 void
2107 {
2108 HASH_SEQ_STATUS status;
2111 /*
2112 * To speed up transaction exit, we want to avoid scanning the relcache
2113 * unless there is actually something for this routine to do. Other than
2114 * the debug-only Assert checks, most transactions don't create any work
2115 * for us to do here, so we keep a static flag that gets set if there is
2116 * anything to do. (Currently, this means either a relation is created in
2117 * the current xact, or one is given a new relfilenode, or an index list
2118 * is forced.) For simplicity, the flag remains set till end of top-level
2119 * transaction, even though we could clear it at subtransaction end in
2120 * some cases.
2121 */
2123 #ifdef USE_ASSERT_CHECKING
2124 && !assert_enabled
2125 #endif
2126 )
2132 {
2135 /*
2136 * The relcache entry's ref count should be back to its normal
2137 * not-in-a-transaction state: 0 unless it's nailed in cache.
2138 *
2139 * In bootstrap mode, this is NOT true, so don't check it --- the
2140 * bootstrap code expects relations to stay open across start/commit
2141 * transaction calls. (That seems bogus, but it's not worth fixing.)
2142 */
2143 #ifdef USE_ASSERT_CHECKING
2145 {
2150 }
2151 #endif
2153 /*
2154 * Is it a relation created in the current transaction?
2155 *
2156 * During commit, reset the flag to zero, since we are now out of the
2157 * creating transaction. During abort, simply delete the relcache
2158 * entry --- it isn't interesting any longer. (NOTE: if we have
2159 * forgotten the new-ness of a new relation due to a forced cache
2160 * flush, the entry will get deleted anyway by shared-cache-inval
2161 * processing of the aborted pg_class insertion.)
2162 */
2164 {
2167 else
2168 {
2171 }
2172 }
2174 /*
2175 * Likewise, reset the hint about the relfilenode being new.
2176 */
2179 /*
2180 * Flush any temporary index list.
2181 */
2183 {
2188 }
2189 }
2191 /* Once done with the transaction, we can reset need_eoxact_work */
2193 }
2195 /*
2196 * AtEOSubXact_RelationCache
2197 *
2198 * Clean up the relcache at sub-transaction commit or abort.
2199 *
2200 * Note: this must be called *before* processing invalidation messages.
2201 */
2202 void
2204 SubTransactionId parentSubid)
2205 {
2206 HASH_SEQ_STATUS status;
2209 /*
2210 * Skip the relcache scan if nothing to do --- see notes for
2211 * AtEOXact_RelationCache.
2212 */
2219 {
2222 /*
2223 * Is it a relation created in the current subtransaction?
2224 *
2225 * During subcommit, mark it as belonging to the parent, instead.
2226 * During subabort, simply delete the relcache entry.
2227 */
2229 {
2232 else
2233 {
2237 }
2238 }
2240 /*
2241 * Likewise, update or drop any new-relfilenode-in-subtransaction
2242 * hint.
2243 */
2245 {
2248 else
2250 }
2252 /*
2253 * Flush any temporary index list.
2254 */
2256 {
2261 }
2262 }
2263 }
2265 /*
2266 * RelationCacheMarkNewRelfilenode
2267 *
2268 * Mark the rel as having been given a new relfilenode in the current
2269 * (sub) transaction. This is a hint that can be used to optimize
2270 * later operations on the rel in the same transaction.
2271 */
2272 void
2274 {
2275 /* Mark it... */
2277 /* ... and now we have eoxact cleanup work to do */
2279 }
2282 /*
2283 * RelationBuildLocalRelation
2284 * Build a relcache entry for an about-to-be-created relation,
2285 * and enter it into the relcache.
2286 */
2287 Relation
2289 Oid relnamespace,
2290 TupleDesc tupDesc,
2291 Oid relid,
2292 Oid reltablespace,
2294 {
2295 Relation rel;
2296 MemoryContext oldcxt;
2304 /*
2305 * check for creation of a rel that must be nailed in cache.
2306 *
2307 * XXX this list had better match RelationCacheInitializePhase2's list.
2308 */
2310 {
2320 }
2322 /*
2323 * check that hardwired list of shared rels matches what's in the
2324 * bootstrap .bki file. If you get a failure here during initdb, you
2325 * probably need to fix IsSharedRelation() to match whatever you've done
2326 * to the set of shared relations.
2327 */
2332 /*
2333 * switch to the cache context to create the relcache entry.
2334 */
2340 /*
2341 * allocate a new relation descriptor and fill in basic state fields.
2342 */
2349 /* make sure relation is marked as having no open file yet */
2352 /* mark it nailed if appropriate */
2357 /* it's being created in this transaction */
2361 /* must flag that we have rels created in this transaction */
2364 /* it is temporary if and only if it is in my temp-table namespace */
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 */
2427 /*
2428 * Okay to insert into the relcache hash tables.
2429 */
2432 /*
2433 * done building relcache entry.
2434 */
2437 /* It's fully valid */
2440 /*
2441 * Caller expects us to pin the returned entry.
2442 */
2446 }
2448 /*
2449 * RelationCacheInitialize
2450 *
2451 * This initializes the relation descriptor cache. At the time
2452 * that this is invoked, we can't do database access yet (mainly
2453 * because the transaction subsystem is not up); all we are doing
2454 * is making an empty cache hashtable. This must be done before
2455 * starting the initialization transaction, because otherwise
2456 * AtEOXact_RelationCache would crash if that transaction aborts
2457 * before we can get the relcache set up.
2458 */
2460 #define INITRELCACHESIZE 400
2462 void
2464 {
2465 MemoryContext oldcxt;
2466 HASHCTL ctl;
2468 /*
2469 * switch to cache memory context
2470 */
2476 /*
2477 * create hashtable that indexes the relcache
2478 */
2487 }
2489 /*
2490 * RelationCacheInitializePhase2
2491 *
2492 * This is called as soon as the catcache and transaction system
2493 * are functional. At this point we can actually read data from
2494 * the system catalogs. We first try to read pre-computed relcache
2495 * entries from the pg_internal.init file. If that's missing or
2496 * broken, make phony entries for the minimum set of nailed-in-cache
2497 * relations. Then (unless bootstrapping) make sure we have entries
2498 * for the critical system indexes. Once we've done all this, we
2499 * have enough infrastructure to open any system catalog or use any
2500 * catcache. The last step is to rewrite pg_internal.init if needed.
2501 */
2502 void
2504 {
2505 HASH_SEQ_STATUS status;
2507 MemoryContext oldcxt;
2510 /*
2511 * switch to cache memory context
2512 */
2515 /*
2516 * Try to load the relcache cache file. If unsuccessful, bootstrap the
2517 * cache with pre-made descriptors for the critical "nailed-in" system
2518 * catalogs.
2519 */
2522 {
2535 }
2539 /* In bootstrap mode, the faked-up formrdesc info is all we'll have */
2543 /*
2544 * If we didn't get the critical system indexes loaded into relcache, do
2545 * so now. These are critical because the catcache and/or opclass cache
2546 * depend on them for fetches done during relcache load. Thus, we have an
2547 * infinite-recursion problem. We can break the recursion by doing
2548 * heapscans instead of indexscans at certain key spots. To avoid hobbling
2549 * performance, we only want to do that until we have the critical indexes
2550 * loaded into relcache. Thus, the flag criticalRelcachesBuilt is used to
2551 * decide whether to do heapscan or indexscan at the key spots, and we set
2552 * it true after we've loaded the critical indexes.
2553 *
2554 * The critical indexes are marked as "nailed in cache", partly to make it
2555 * easy for load_relcache_init_file to count them, but mainly because we
2556 * cannot flush and rebuild them once we've set criticalRelcachesBuilt to
2557 * true. (NOTE: perhaps it would be possible to reload them by
2558 * temporarily setting criticalRelcachesBuilt to false again. For now,
2559 * though, we just nail 'em in.)
2560 *
2561 * RewriteRelRulenameIndexId and TriggerRelidNameIndexId are not critical
2562 * in the same way as the others, because the critical catalogs don't
2563 * (currently) have any rules or triggers, and so these indexes can be
2564 * rebuilt without inducing recursion. However they are used during
2565 * relcache load when a rel does have rules or triggers, so we choose to
2566 * nail them for performance reasons.
2567 */
2569 {
2570 Relation ird;
2572 #define LOAD_CRIT_INDEX(indexoid) \
2573 do { \
2574 LockRelationOid(indexoid, AccessShareLock); \
2575 ird = RelationBuildDesc(indexoid, NULL); \
2576 if (ird == NULL) \
2578 indexoid); \
2579 ird->rd_isnailed = true; \
2580 ird->rd_refcnt = 1; \
2581 UnlockRelationOid(indexoid, AccessShareLock); \
2582 } while (0)
2597 }
2599 /*
2600 * Now, scan all the relcache entries and update anything that might be
2601 * wrong in the results from formrdesc or the relcache cache file. If we
2602 * faked up relcache entries using formrdesc, then read the real pg_class
2603 * rows and replace the fake entries with them. Also, if any of the
2604 * relcache entries have rules or triggers, load that info the hard way
2605 * since it isn't recorded in the cache file.
2606 */
2610 {
2613 /*
2614 * If it's a faked-up entry, read the real pg_class tuple.
2615 */
2617 {
2618 HeapTuple htup;
2619 Form_pg_class relp;
2629 /*
2630 * Copy tuple to relation->rd_rel. (See notes in
2631 * AllocateRelationDesc())
2632 */
2636 /* Update rd_options while we have the tuple */
2641 /*
2642 * Also update the derived fields in rd_att.
2643 */
2649 }
2651 /*
2652 * Fix data that isn't saved in relcache cache file.
2653 */
2658 }
2660 /*
2661 * Lastly, write out a new relcache cache file if one is needed.
2662 */
2664 {
2665 /*
2666 * Force all the catcaches to finish initializing and thereby open the
2667 * catalogs and indexes they use. This will preload the relcache with
2668 * entries for all the most important system catalogs and indexes, so
2669 * that the init file will be most useful for future backends.
2670 */
2673 /* now write the file */
2675 }
2676 }
2678 /*
2679 * GetPgClassDescriptor -- get a predefined tuple descriptor for pg_class
2680 * GetPgIndexDescriptor -- get a predefined tuple descriptor for pg_index
2681 *
2682 * We need this kluge because we have to be able to access non-fixed-width
2683 * fields of pg_class and pg_index before we have the standard catalog caches
2684 * available. We use predefined data that's set up in just the same way as
2685 * the bootstrapped reldescs used by formrdesc(). The resulting tupdesc is
2686 * not 100% kosher: it does not have the correct rowtype OID in tdtypeid, nor
2687 * does it have a TupleConstr field. But it's good enough for the purpose of
2688 * extracting fields.
2689 */
2690 static TupleDesc
2692 {
2693 TupleDesc result;
2694 MemoryContext oldcxt;
2704 {
2706 /* make sure attcacheoff is valid */
2708 }
2710 /* initialize first attribute's attcacheoff, cf RelationBuildTupleDesc */
2713 /* Note: we don't bother to set up a TupleConstr entry */
2718 }
2720 static TupleDesc
2722 {
2725 /* Already done? */
2728 Desc_pg_class,
2732 }
2734 static TupleDesc
2736 {
2739 /* Already done? */
2742 Desc_pg_index,
2746 }
2748 static void
2750 {
2753 Relation adrel;
2754 SysScanDesc adscan;
2755 ScanKeyData skey;
2756 HeapTuple htup;
2757 Datum val;
2763 Anum_pg_attrdef_adrelid,
2773 {
2777 {
2784 else
2785 found++;
2788 Anum_pg_attrdef_adbin,
2794 else
2798 }
2803 }
2811 }
2813 static void
2815 {
2818 Relation conrel;
2819 SysScanDesc conscan;
2821 HeapTuple htup;
2822 Datum val;
2827 Anum_pg_constraint_conrelid,
2836 {
2839 /* We want check constraints only */
2850 /* Grab and test conbin is actually set */
2852 Anum_pg_constraint_conbin,
2860 found++;
2861 }
2869 }
2871 /*
2872 * RelationGetIndexList -- get a list of OIDs of indexes on this relation
2873 *
2874 * The index list is created only if someone requests it. We scan pg_index
2875 * to find relevant indexes, and add the list to the relcache entry so that
2876 * we won't have to compute it again. Note that shared cache inval of a
2877 * relcache entry will delete the old list and set rd_indexvalid to 0,
2878 * so that we must recompute the index list on next request. This handles
2879 * creation or deletion of an index.
2880 *
2881 * The returned list is guaranteed to be sorted in order by OID. This is
2882 * needed by the executor, since for index types that we obtain exclusive
2883 * locks on when updating the index, all backends must lock the indexes in
2884 * the same order or we will get deadlocks (see ExecOpenIndices()). Any
2885 * consistent ordering would do, but ordering by OID is easy.
2886 *
2887 * Since shared cache inval causes the relcache's copy of the list to go away,
2888 * we return a copy of the list palloc'd in the caller's context. The caller
2889 * may list_free() the returned list after scanning it. This is necessary
2890 * since the caller will typically be doing syscache lookups on the relevant
2891 * indexes, and syscache lookup could cause SI messages to be processed!
2892 *
2893 * We also update rd_oidindex, which this module treats as effectively part
2894 * of the index list. rd_oidindex is valid when rd_indexvalid isn't zero;
2895 * it is the pg_class OID of a unique index on OID when the relation has one,
2896 * and InvalidOid if there is no such index.
2897 */
2898 List *
2900 {
2901 Relation indrel;
2902 SysScanDesc indscan;
2903 ScanKeyData skey;
2904 HeapTuple htup;
2906 Oid oidIndex;
2907 MemoryContext oldcxt;
2909 /* Quick exit if we already computed the list. */
2913 /*
2914 * We build the list we intend to return (in the caller's context) while
2915 * doing the scan. After successfully completing the scan, we copy that
2916 * list into the relcache entry. This avoids cache-context memory leakage
2917 * if we get some sort of error partway through.
2918 */
2922 /* Prepare to scan pg_index for entries having indrelid = this rel. */
2924 Anum_pg_index_indrelid,
2933 {
2936 /* Add index's OID to result list in the proper order */
2939 /* Check to see if it is a unique, non-partial btree index on OID */
2946 }
2951 /* Now save a copy of the completed list in the relcache entry. */
2959 }
2961 /*
2962 * insert_ordered_oid
2963 * Insert a new Oid into a sorted list of Oids, preserving ordering
2964 *
2965 * Building the ordered list this way is O(N^2), but with a pretty small
2966 * constant, so for the number of entries we expect it will probably be
2967 * faster than trying to apply qsort(). Most tables don't have very many
2968 * indexes...
2969 */
2972 {
2975 /* Does the datum belong at the front? */
2978 /* No, so find the entry it belongs after */
2981 {
2988 }
2989 /* Insert datum into list after 'prev' */
2992 }
2994 /*
2995 * RelationSetIndexList -- externally force the index list contents
2996 *
2997 * This is used to temporarily override what we think the set of valid
2998 * indexes is (including the presence or absence of an OID index).
2999 * The forcing will be valid only until transaction commit or abort.
3000 *
3001 * This should only be applied to nailed relations, because in a non-nailed
3002 * relation the hacked index list could be lost at any time due to SI
3003 * messages. In practice it is only used on pg_class (see REINDEX).
3004 *
3005 * It is up to the caller to make sure the given list is correctly ordered.
3006 *
3007 * We deliberately do not change rd_indexattr here: even when operating
3008 * with a temporary partial index list, HOT-update decisions must be made
3009 * correctly with respect to the full index set. It is up to the caller
3010 * to ensure that a correct rd_indexattr set has been cached before first
3011 * calling RelationSetIndexList; else a subsequent inquiry might cause a
3012 * wrong rd_indexattr set to get computed and cached.
3013 */
3014 void
3016 {
3017 MemoryContext oldcxt;
3020 /* Copy the list into the cache context (could fail for lack of mem) */
3024 /* Okay to replace old list */
3029 /* must flag that we have a forced index list */
3031 }
3033 /*
3034 * RelationGetOidIndex -- get the pg_class OID of the relation's OID index
3035 *
3036 * Returns InvalidOid if there is no such index.
3037 */
3038 Oid
3040 {
3043 /*
3044 * If relation doesn't have OIDs at all, caller is probably confused. (We
3045 * could just silently return InvalidOid, but it seems better to throw an
3046 * assertion.)
3047 */
3051 {
3052 /* RelationGetIndexList does the heavy lifting. */
3056 }
3059 }
3061 /*
3062 * RelationGetIndexExpressions -- get the index expressions for an index
3063 *
3064 * We cache the result of transforming pg_index.indexprs into a node tree.
3065 * If the rel is not an index or has no expressional columns, we return NIL.
3066 * Otherwise, the returned tree is copied into the caller's memory context.
3067 * (We don't want to return a pointer to the relcache copy, since it could
3068 * disappear due to relcache invalidation.)
3069 */
3070 List *
3072 {
3074 Datum exprsDatum;
3077 MemoryContext oldcxt;
3079 /* Quick exit if we already computed the result. */
3083 /* Quick exit if there is nothing to do. */
3088 /*
3089 * We build the tree we intend to return in the caller's context. After
3090 * successfully completing the work, we copy it into the relcache entry.
3091 * This avoids problems if we get some sort of error partway through.
3092 */
3094 Anum_pg_index_indexprs,
3102 /*
3103 * Run the expressions through eval_const_expressions. This is not just an
3104 * optimization, but is necessary, because the planner will be comparing
3105 * them to similarly-processed qual clauses, and may fail to detect valid
3106 * matches without this. We don't bother with canonicalize_qual, however.
3107 */
3110 /*
3111 * Also mark any coercion format fields as "don't care", so that the
3112 * planner can match to both explicit and implicit coercions.
3113 */
3116 /* May as well fix opfuncids too */
3119 /* Now save a copy of the completed tree in the relcache entry. */
3125 }
3127 /*
3128 * RelationGetIndexPredicate -- get the index predicate for an index
3129 *
3130 * We cache the result of transforming pg_index.indpred into an implicit-AND
3131 * node tree (suitable for ExecQual).
3132 * If the rel is not an index or has no predicate, we return NIL.
3133 * Otherwise, the returned tree is copied into the caller's memory context.
3134 * (We don't want to return a pointer to the relcache copy, since it could
3135 * disappear due to relcache invalidation.)
3136 */
3137 List *
3139 {
3141 Datum predDatum;
3144 MemoryContext oldcxt;
3146 /* Quick exit if we already computed the result. */
3150 /* Quick exit if there is nothing to do. */
3155 /*
3156 * We build the tree we intend to return in the caller's context. After
3157 * successfully completing the work, we copy it into the relcache entry.
3158 * This avoids problems if we get some sort of error partway through.
3159 */
3161 Anum_pg_index_indpred,
3169 /*
3170 * Run the expression through const-simplification and canonicalization.
3171 * This is not just an optimization, but is necessary, because the planner
3172 * will be comparing it to similarly-processed qual clauses, and may fail
3173 * to detect valid matches without this. This must match the processing
3174 * done to qual clauses in preprocess_expression()! (We can skip the
3175 * stuff involving subqueries, however, since we don't allow any in index
3176 * predicates.)
3177 */
3182 /*
3183 * Also mark any coercion format fields as "don't care", so that the
3184 * planner can match to both explicit and implicit coercions.
3185 */
3188 /* Also convert to implicit-AND format */
3191 /* May as well fix opfuncids too */
3194 /* Now save a copy of the completed tree in the relcache entry. */
3200 }
3202 /*
3203 * RelationGetIndexAttrBitmap -- get a bitmap of index attribute numbers
3204 *
3205 * The result has a bit set for each attribute used anywhere in the index
3206 * definitions of all the indexes on this relation. (This includes not only
3207 * simple index keys, but attributes used in expressions and partial-index
3208 * predicates.)
3209 *
3210 * Attribute numbers are offset by FirstLowInvalidHeapAttributeNumber so that
3211 * we can include system attributes (e.g., OID) in the bitmap representation.
3212 *
3213 * The returned result is palloc'd in the caller's memory context and should
3214 * be bms_free'd when not needed anymore.
3215 */
3216 Bitmapset *
3218 {
3222 MemoryContext oldcxt;
3224 /* Quick exit if we already computed the result. */
3228 /* Fast path if definitely no indexes */
3232 /*
3233 * Get cached list of index OIDs
3234 */
3237 /* Fall out if no indexes (but relhasindex was set) */
3241 /*
3242 * For each index, add referenced attributes to indexattrs.
3243 */
3246 {
3248 Relation indexDesc;
3254 /* Extract index key information from the index's pg_index row */
3257 /* Collect simple attribute references */
3259 {
3265 }
3267 /* Collect all attributes used in expressions, too */
3270 /* Collect all attributes in the index predicate, too */
3274 }
3278 /* Now save a copy of the bitmap in the relcache entry. */
3283 /* We return our original working copy for caller to play with */
3285 }
3288 /*
3289 * load_relcache_init_file, write_relcache_init_file
3290 *
3291 * In late 1992, we started regularly having databases with more than
3292 * a thousand classes in them. With this number of classes, it became
3293 * critical to do indexed lookups on the system catalogs.
3294 *
3295 * Bootstrapping these lookups is very hard. We want to be able to
3296 * use an index on pg_attribute, for example, but in order to do so,
3297 * we must have read pg_attribute for the attributes in the index,
3298 * which implies that we need to use the index.
3299 *
3300 * In order to get around the problem, we do the following:
3301 *
3302 * + When the database system is initialized (at initdb time), we
3303 * don't use indexes. We do sequential scans.
3304 *
3305 * + When the backend is started up in normal mode, we load an image
3306 * of the appropriate relation descriptors, in internal format,
3307 * from an initialization file in the data/base/... directory.
3308 *
3309 * + If the initialization file isn't there, then we create the
3310 * relation descriptors using sequential scans and write 'em to
3311 * the initialization file for use by subsequent backends.
3312 *
3313 * We could dispense with the initialization file and just build the
3314 * critical reldescs the hard way on every backend startup, but that
3315 * slows down backend startup noticeably.
3316 *
3317 * We can in fact go further, and save more relcache entries than
3318 * just the ones that are absolutely critical; this allows us to speed
3319 * up backend startup by not having to build such entries the hard way.
3320 * Presently, all the catalog and index entries that are referred to
3321 * by catcaches are stored in the initialization file.
3322 *
3323 * The same mechanism that detects when catcache and relcache entries
3324 * need to be invalidated (due to catalog updates) also arranges to
3325 * unlink the initialization file when its contents may be out of date.
3326 * The file will then be rebuilt during the next backend startup.
3327 */
3329 /*
3330 * load_relcache_init_file -- attempt to load cache from the init file
3331 *
3332 * If successful, return TRUE and set criticalRelcachesBuilt to true.
3333 * If not successful, return FALSE.
3334 *
3335 * NOTE: we assume we are already switched into CacheMemoryContext.
3336 */
3337 static bool
3339 {
3344 num_rels,
3345 max_rels,
3346 nailed_rels,
3347 nailed_indexes,
3348 magic;
3358 /*
3359 * Read the index relcache entries from the file. Note we will not enter
3360 * any of them into the cache if the read fails partway through; this
3361 * helps to guard against broken init files.
3362 */
3369 /* check for correct magic number (compatible version) */
3376 {
3377 Size len;
3379 Relation rel;
3380 Form_pg_class relform;
3383 /* first read the relation descriptor length */
3385 {
3389 }
3391 /* safety check for incompatible relcache layout */
3395 /* allocate another relcache header */
3397 {
3400 }
3404 /* then, read the Relation structure */
3408 /* next read the relation tuple form */
3418 /* initialize attribute tuple forms */
3426 /* next read all the attribute tuple form data entries */
3429 {
3438 }
3440 /* next read the access method specific field */
3444 {
3450 }
3451 else
3452 {
3454 }
3456 /* mark not-null status */
3458 {
3463 }
3465 /* If it's an index, there's more to do */
3467 {
3468 Form_pg_am am;
3469 MemoryContext indexcxt;
3477 /* Count nailed indexes to ensure we have 'em all */
3479 nailed_indexes++;
3481 /* next, read the pg_index tuple */
3489 /* Fix up internal pointers in the tuple -- see heap_copytuple */
3493 /* next, read the access method tuple form */
3502 /*
3503 * prepare index info context --- parameters should match
3504 * RelationInitIndexAccessInfo
3505 */
3508 ALLOCSET_SMALL_MINSIZE,
3509 ALLOCSET_SMALL_INITSIZE,
3510 ALLOCSET_SMALL_MAXSIZE);
3513 /* next, read the vector of opfamily OIDs */
3523 /* next, read the vector of opcintype OIDs */
3533 /* next, read the vector of operator OIDs */
3543 /* next, read the vector of support procedures */
3552 /* finally, read the vector of indoption values */
3562 /* set up zeroed fmgr-info vectors */
3568 }
3569 else
3570 {
3571 /* Count nailed rels to ensure we have 'em all */
3573 nailed_rels++;
3586 }
3588 /*
3589 * Rules and triggers are not saved (mainly because the internal
3590 * format is complex and subject to change). They must be rebuilt if
3591 * needed by RelationCacheInitializePhase2. This is not expected to
3592 * be a big performance hit since few system catalogs have such. Ditto
3593 * for index expressions and predicates.
3594 */
3601 /*
3602 * Reset transient-state fields in the relcache entry
3603 */
3610 else
3621 /*
3622 * Recompute lock and physical addressing info. This is needed in
3623 * case the pg_internal.init file was copied from some other database
3624 * by CREATE DATABASE.
3625 */
3628 }
3630 /*
3631 * We reached the end of the init file without apparent problem. Did we
3632 * get the right number of nailed items? (This is a useful crosscheck in
3633 * case the set of critical rels or indexes changes.)
3634 */
3639 /*
3640 * OK, all appears well.
3641 *
3642 * Now insert all the new relcache entries into the cache.
3643 */
3645 {
3647 /* also make a list of their OIDs, for RelationIdIsInInitFile */
3649 initFileRelationIds);
3650 }
3658 /*
3659 * init file is broken, so do it the hard way. We don't bother trying to
3660 * free the clutter we just allocated; it's not in the relcache so it
3661 * won't hurt.
3662 */
3663 read_failed:
3668 }
3670 /*
3671 * Write out a new initialization file with the current contents
3672 * of the relcache.
3673 */
3674 static void
3676 {
3681 HASH_SEQ_STATUS status;
3683 MemoryContext oldcxt;
3686 /*
3687 * We must write a temporary file and rename it into place. Otherwise,
3688 * another backend starting at about the same time might crash trying to
3689 * read the partially-complete file.
3690 */
3700 {
3701 /*
3702 * We used to consider this a fatal error, but we might as well
3703 * continue with backend startup ...
3704 */
3708 tempfilename),
3711 }
3713 /*
3714 * Write a magic number to serve as a file version identifier. We can
3715 * change the magic number whenever the relcache layout changes.
3716 */
3721 /*
3722 * Write all the reldescs (in no particular order).
3723 */
3729 {
3733 /* first write the relcache entry proper */
3736 /* next write the relation tuple form */
3739 /* next, do all the attribute tuple form data entries */
3741 {
3743 }
3745 /* next, do the access method specific field */
3748 fp);
3750 /* If it's an index, there's more to do */
3752 {
3755 /* write the pg_index tuple */
3756 /* we assume this was created by heap_copytuple! */
3759 fp);
3761 /* next, write the access method tuple form */
3764 /* next, write the vector of opfamily OIDs */
3767 fp);
3769 /* next, write the vector of opcintype OIDs */
3772 fp);
3774 /* next, write the vector of operator OIDs */
3777 fp);
3779 /* next, write the vector of support procedures */
3782 fp);
3784 /* finally, write the vector of indoption values */
3787 fp);
3788 }
3790 /* also make a list of their OIDs, for RelationIdIsInInitFile */
3793 initFileRelationIds);
3795 }
3800 /*
3801 * Now we have to check whether the data we've so painstakingly
3802 * accumulated is already obsolete due to someone else's just-committed
3803 * catalog changes. If so, we just delete the temp file and leave it to
3804 * the next backend to try again. (Our own relcache entries will be
3805 * updated by SI message processing, but we can't be sure whether what we
3806 * wrote out was up-to-date.)
3807 *
3808 * This mustn't run concurrently with RelationCacheInitFileInvalidate, so
3809 * grab a serialization lock for the duration.
3810 */
3813 /* Make sure we have seen all incoming SI messages */
3816 /*
3817 * If we have received any SI relcache invals since backend start, assume
3818 * we may have written out-of-date data.
3819 */
3821 {
3822 /*
3823 * OK, rename the temp file to its final name, deleting any
3824 * previously-existing init file.
3825 *
3826 * Note: a failure here is possible under Cygwin, if some other
3827 * backend is holding open an unlinked-but-not-yet-gone init file. So
3828 * treat this as a noncritical failure; just remove the useless temp
3829 * file on failure.
3830 */
3833 }
3834 else
3835 {
3836 /* Delete the already-obsolete temp file */
3838 }
3841 }
3843 /* write a chunk of data preceded by its length */
3844 static void
3846 {
3851 }
3853 /*
3854 * Detect whether a given relation (identified by OID) is one of the ones
3855 * we store in the init file.
3856 *
3857 * Note that we effectively assume that all backends running in a database
3858 * would choose to store the same set of relations in the init file;
3859 * otherwise there are cases where we'd fail to detect the need for an init
3860 * file invalidation. This does not seem likely to be a problem in practice.
3861 */
3862 bool
3864 {
3866 }
3868 /*
3869 * Invalidate (remove) the init file during commit of a transaction that
3870 * changed one or more of the relation cache entries that are kept in the
3871 * init file.
3872 *
3873 * We actually need to remove the init file twice: once just before sending
3874 * the SI messages that include relcache inval for such relations, and once
3875 * just after sending them. The unlink before ensures that a backend that's
3876 * currently starting cannot read the now-obsolete init file and then miss
3877 * the SI messages that will force it to update its relcache entries. (This
3878 * works because the backend startup sequence gets into the PGPROC array before
3879 * trying to load the init file.) The unlink after is to synchronize with a
3880 * backend that may currently be trying to write an init file based on data
3881 * that we've just rendered invalid. Such a backend will see the SI messages,
3882 * but we can't leave the init file sitting around to fool later backends.
3883 *
3884 * Ignore any failure to unlink the file, since it might not be there if
3885 * no backend has been started since the last removal.
3886 */
3887 void
3889 {
3896 {
3897 /* no interlock needed here */
3899 }
3900 else
3901 {
3902 /*
3903 * We need to interlock this against write_relcache_init_file, to
3904 * guard against possibility that someone renames a new-but-
3905 * already-obsolete init file into place just after we unlink. With
3906 * the interlock, it's certain that write_relcache_init_file will
3907 * notice our SI inval message before renaming into place, or else
3908 * that we will execute second and successfully unlink the file.
3909 */
3913 }
3914 }
3916 /*
3917 * Remove the init file for a given database during postmaster startup.
3918 *
3919 * We used to keep the init file across restarts, but that is unsafe in PITR
3920 * scenarios, and even in simple crash-recovery cases there are windows for
3921 * the init file to become out-of-sync with the database. So now we just
3922 * remove it during startup and expect the first backend launch to rebuild it.
3923 * Of course, this has to happen in each database of the cluster. For
3924 * simplicity this is driven by flatfiles.c, which has to scan pg_database
3925 * anyway.
3926 */
3927 void
3929 {
3935 /* ignore any error, since it might not be there at all */
3936 }