LCOV - code coverage report
Current view: top level - src/backend/utils/cache - relfilenumbermap.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 59 63 93.7 %
Date: 2024-12-12 20:14:52 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * relfilenumbermap.c
       4             :  *    relfilenumber to oid mapping cache.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/cache/relfilenumbermap.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres.h"
      15             : 
      16             : #include "access/genam.h"
      17             : #include "access/htup_details.h"
      18             : #include "access/table.h"
      19             : #include "catalog/pg_class.h"
      20             : #include "catalog/pg_tablespace.h"
      21             : #include "miscadmin.h"
      22             : #include "utils/catcache.h"
      23             : #include "utils/fmgroids.h"
      24             : #include "utils/hsearch.h"
      25             : #include "utils/inval.h"
      26             : #include "utils/relfilenumbermap.h"
      27             : #include "utils/relmapper.h"
      28             : 
      29             : /* Hash table for information about each relfilenumber <-> oid pair */
      30             : static HTAB *RelfilenumberMapHash = NULL;
      31             : 
      32             : /* built first time through in InitializeRelfilenumberMap */
      33             : static ScanKeyData relfilenumber_skey[2];
      34             : 
      35             : typedef struct
      36             : {
      37             :     Oid         reltablespace;
      38             :     RelFileNumber relfilenumber;
      39             : } RelfilenumberMapKey;
      40             : 
      41             : typedef struct
      42             : {
      43             :     RelfilenumberMapKey key;    /* lookup key - must be first */
      44             :     Oid         relid;          /* pg_class.oid */
      45             : } RelfilenumberMapEntry;
      46             : 
      47             : /*
      48             :  * RelfilenumberMapInvalidateCallback
      49             :  *      Flush mapping entries when pg_class is updated in a relevant fashion.
      50             :  */
      51             : static void
      52       37940 : RelfilenumberMapInvalidateCallback(Datum arg, Oid relid)
      53             : {
      54             :     HASH_SEQ_STATUS status;
      55             :     RelfilenumberMapEntry *entry;
      56             : 
      57             :     /* callback only gets registered after creating the hash */
      58             :     Assert(RelfilenumberMapHash != NULL);
      59             : 
      60       37940 :     hash_seq_init(&status, RelfilenumberMapHash);
      61    20733712 :     while ((entry = (RelfilenumberMapEntry *) hash_seq_search(&status)) != NULL)
      62             :     {
      63             :         /*
      64             :          * If relid is InvalidOid, signaling a complete reset, we must remove
      65             :          * all entries, otherwise just remove the specific relation's entry.
      66             :          * Always remove negative cache entries.
      67             :          */
      68    20695772 :         if (relid == InvalidOid ||  /* complete reset */
      69    20694886 :             entry->relid == InvalidOid ||    /* negative cache entry */
      70    20694774 :             entry->relid == relid)   /* individual flushed relation */
      71             :         {
      72        1424 :             if (hash_search(RelfilenumberMapHash,
      73        1424 :                             &entry->key,
      74             :                             HASH_REMOVE,
      75             :                             NULL) == NULL)
      76           0 :                 elog(ERROR, "hash table corrupted");
      77             :         }
      78             :     }
      79       37940 : }
      80             : 
      81             : /*
      82             :  * InitializeRelfilenumberMap
      83             :  *      Initialize cache, either on first use or after a reset.
      84             :  */
      85             : static void
      86         388 : InitializeRelfilenumberMap(void)
      87             : {
      88             :     HASHCTL     ctl;
      89             :     int         i;
      90             : 
      91             :     /* Make sure we've initialized CacheMemoryContext. */
      92         388 :     if (CacheMemoryContext == NULL)
      93           0 :         CreateCacheMemoryContext();
      94             : 
      95             :     /* build skey */
      96        7372 :     MemSet(&relfilenumber_skey, 0, sizeof(relfilenumber_skey));
      97             : 
      98        1164 :     for (i = 0; i < 2; i++)
      99             :     {
     100         776 :         fmgr_info_cxt(F_OIDEQ,
     101             :                       &relfilenumber_skey[i].sk_func,
     102             :                       CacheMemoryContext);
     103         776 :         relfilenumber_skey[i].sk_strategy = BTEqualStrategyNumber;
     104         776 :         relfilenumber_skey[i].sk_subtype = InvalidOid;
     105         776 :         relfilenumber_skey[i].sk_collation = InvalidOid;
     106             :     }
     107             : 
     108         388 :     relfilenumber_skey[0].sk_attno = Anum_pg_class_reltablespace;
     109         388 :     relfilenumber_skey[1].sk_attno = Anum_pg_class_relfilenode;
     110             : 
     111             :     /*
     112             :      * Only create the RelfilenumberMapHash now, so we don't end up partially
     113             :      * initialized when fmgr_info_cxt() above ERRORs out with an out of memory
     114             :      * error.
     115             :      */
     116         388 :     ctl.keysize = sizeof(RelfilenumberMapKey);
     117         388 :     ctl.entrysize = sizeof(RelfilenumberMapEntry);
     118         388 :     ctl.hcxt = CacheMemoryContext;
     119             : 
     120         388 :     RelfilenumberMapHash =
     121         388 :         hash_create("RelfilenumberMap cache", 64, &ctl,
     122             :                     HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
     123             : 
     124             :     /* Watch for invalidation events. */
     125         388 :     CacheRegisterRelcacheCallback(RelfilenumberMapInvalidateCallback,
     126             :                                   (Datum) 0);
     127         388 : }
     128             : 
     129             : /*
     130             :  * Map a relation's (tablespace, relfilenumber) to a relation's oid and cache
     131             :  * the result.
     132             :  *
     133             :  * Returns InvalidOid if no relation matching the criteria could be found.
     134             :  */
     135             : Oid
     136      689042 : RelidByRelfilenumber(Oid reltablespace, RelFileNumber relfilenumber)
     137             : {
     138             :     RelfilenumberMapKey key;
     139             :     RelfilenumberMapEntry *entry;
     140             :     bool        found;
     141             :     SysScanDesc scandesc;
     142             :     Relation    relation;
     143             :     HeapTuple   ntp;
     144             :     Oid         relid;
     145             : 
     146      689042 :     if (RelfilenumberMapHash == NULL)
     147         388 :         InitializeRelfilenumberMap();
     148             : 
     149             :     /* pg_class will show 0 when the value is actually MyDatabaseTableSpace */
     150      689042 :     if (reltablespace == MyDatabaseTableSpace)
     151      681032 :         reltablespace = 0;
     152             : 
     153     1378084 :     MemSet(&key, 0, sizeof(key));
     154      689042 :     key.reltablespace = reltablespace;
     155      689042 :     key.relfilenumber = relfilenumber;
     156             : 
     157             :     /*
     158             :      * Check cache and return entry if one is found. Even if no target
     159             :      * relation can be found later on we store the negative match and return a
     160             :      * InvalidOid from cache. That's not really necessary for performance
     161             :      * since querying invalid values isn't supposed to be a frequent thing,
     162             :      * but it's basically free.
     163             :      */
     164      689042 :     entry = hash_search(RelfilenumberMapHash, &key, HASH_FIND, &found);
     165             : 
     166      689042 :     if (found)
     167      678756 :         return entry->relid;
     168             : 
     169             :     /* ok, no previous cache entry, do it the hard way */
     170             : 
     171             :     /* initialize empty/negative cache entry before doing the actual lookups */
     172       10286 :     relid = InvalidOid;
     173             : 
     174       10286 :     if (reltablespace == GLOBALTABLESPACE_OID)
     175             :     {
     176             :         /*
     177             :          * Ok, shared table, check relmapper.
     178             :          */
     179         306 :         relid = RelationMapFilenumberToOid(relfilenumber, true);
     180             :     }
     181             :     else
     182             :     {
     183             :         ScanKeyData skey[2];
     184             : 
     185             :         /*
     186             :          * Not a shared table, could either be a plain relation or a
     187             :          * non-shared, nailed one, like e.g. pg_class.
     188             :          */
     189             : 
     190             :         /* check for plain relations by looking in pg_class */
     191        9980 :         relation = table_open(RelationRelationId, AccessShareLock);
     192             : 
     193             :         /* copy scankey to local copy and set scan arguments */
     194        9974 :         memcpy(skey, relfilenumber_skey, sizeof(skey));
     195        9974 :         skey[0].sk_argument = ObjectIdGetDatum(reltablespace);
     196        9974 :         skey[1].sk_argument = ObjectIdGetDatum(relfilenumber);
     197             : 
     198        9974 :         scandesc = systable_beginscan(relation,
     199             :                                       ClassTblspcRelfilenodeIndexId,
     200             :                                       true,
     201             :                                       NULL,
     202             :                                       2,
     203             :                                       skey);
     204             : 
     205        9974 :         found = false;
     206             : 
     207       19148 :         while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
     208             :         {
     209        9174 :             Form_pg_class classform = (Form_pg_class) GETSTRUCT(ntp);
     210             : 
     211        9174 :             if (found)
     212           0 :                 elog(ERROR,
     213             :                      "unexpected duplicate for tablespace %u, relfilenumber %u",
     214             :                      reltablespace, relfilenumber);
     215        9174 :             found = true;
     216             : 
     217             :             Assert(classform->reltablespace == reltablespace);
     218             :             Assert(classform->relfilenode == relfilenumber);
     219        9174 :             relid = classform->oid;
     220             :         }
     221             : 
     222        9964 :         systable_endscan(scandesc);
     223        9964 :         table_close(relation, AccessShareLock);
     224             : 
     225             :         /* check for tables that are mapped but not shared */
     226        9964 :         if (!found)
     227         790 :             relid = RelationMapFilenumberToOid(relfilenumber, false);
     228             :     }
     229             : 
     230             :     /*
     231             :      * Only enter entry into cache now, our opening of pg_class could have
     232             :      * caused cache invalidations to be executed which would have deleted a
     233             :      * new entry if we had entered it above.
     234             :      */
     235       10270 :     entry = hash_search(RelfilenumberMapHash, &key, HASH_ENTER, &found);
     236       10270 :     if (found)
     237           0 :         elog(ERROR, "corrupted hashtable");
     238       10270 :     entry->relid = relid;
     239             : 
     240       10270 :     return relid;
     241             : }

Generated by: LCOV version 1.14