LCOV - code coverage report
Current view: top level - src/common - relpath.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 40 43 93.0 %
Date: 2024-03-28 13:11:05 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  * relpath.c
       3             :  *      Shared frontend/backend code to compute pathnames of relation files
       4             :  *
       5             :  * This module also contains some logic associated with fork names.
       6             :  *
       7             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/common/relpath.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : #ifndef FRONTEND
      16             : #include "postgres.h"
      17             : #else
      18             : #include "postgres_fe.h"
      19             : #endif
      20             : 
      21             : #include "catalog/pg_tablespace_d.h"
      22             : #include "common/relpath.h"
      23             : #include "storage/procnumber.h"
      24             : 
      25             : 
      26             : /*
      27             :  * Lookup table of fork name by fork number.
      28             :  *
      29             :  * If you add a new entry, remember to update the errhint in
      30             :  * forkname_to_number() below, and update the SGML documentation for
      31             :  * pg_relation_size().
      32             :  */
      33             : const char *const forkNames[] = {
      34             :     [MAIN_FORKNUM] = "main",
      35             :     [FSM_FORKNUM] = "fsm",
      36             :     [VISIBILITYMAP_FORKNUM] = "vm",
      37             :     [INIT_FORKNUM] = "init",
      38             : };
      39             : 
      40             : StaticAssertDecl(lengthof(forkNames) == (MAX_FORKNUM + 1),
      41             :                  "array length mismatch");
      42             : 
      43             : /*
      44             :  * forkname_to_number - look up fork number by name
      45             :  *
      46             :  * In backend, we throw an error for no match; in frontend, we just
      47             :  * return InvalidForkNumber.
      48             :  */
      49             : ForkNumber
      50        5738 : forkname_to_number(const char *forkName)
      51             : {
      52             :     ForkNumber  forkNum;
      53             : 
      54        5774 :     for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
      55        5770 :         if (strcmp(forkNames[forkNum], forkName) == 0)
      56        5734 :             return forkNum;
      57             : 
      58             : #ifndef FRONTEND
      59           2 :     ereport(ERROR,
      60             :             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
      61             :              errmsg("invalid fork name"),
      62             :              errhint("Valid fork names are \"main\", \"fsm\", "
      63             :                      "\"vm\", and \"init\".")));
      64             : #endif
      65             : 
      66           2 :     return InvalidForkNumber;
      67             : }
      68             : 
      69             : /*
      70             :  * forkname_chars
      71             :  *      We use this to figure out whether a filename could be a relation
      72             :  *      fork (as opposed to an oddly named stray file that somehow ended
      73             :  *      up in the database directory).  If the passed string begins with
      74             :  *      a fork name (other than the main fork name), we return its length,
      75             :  *      and set *fork (if not NULL) to the fork number.  If not, we return 0.
      76             :  *
      77             :  * Note that the present coding assumes that there are no fork names which
      78             :  * are prefixes of other fork names.
      79             :  */
      80             : int
      81      364598 : forkname_chars(const char *str, ForkNumber *fork)
      82             : {
      83             :     ForkNumber  forkNum;
      84             : 
      85      546758 :     for (forkNum = 1; forkNum <= MAX_FORKNUM; forkNum++)
      86             :     {
      87      546758 :         int         len = strlen(forkNames[forkNum]);
      88             : 
      89      546758 :         if (strncmp(forkNames[forkNum], str, len) == 0)
      90             :         {
      91      364598 :             if (fork)
      92      364558 :                 *fork = forkNum;
      93      364598 :             return len;
      94             :         }
      95             :     }
      96           0 :     if (fork)
      97           0 :         *fork = InvalidForkNumber;
      98           0 :     return 0;
      99             : }
     100             : 
     101             : 
     102             : /*
     103             :  * GetDatabasePath - construct path to a database directory
     104             :  *
     105             :  * Result is a palloc'd string.
     106             :  *
     107             :  * XXX this must agree with GetRelationPath()!
     108             :  */
     109             : char *
     110      300390 : GetDatabasePath(Oid dbOid, Oid spcOid)
     111             : {
     112      300390 :     if (spcOid == GLOBALTABLESPACE_OID)
     113             :     {
     114             :         /* Shared system relations live in {datadir}/global */
     115             :         Assert(dbOid == 0);
     116           4 :         return pstrdup("global");
     117             :     }
     118      300386 :     else if (spcOid == DEFAULTTABLESPACE_OID)
     119             :     {
     120             :         /* The default tablespace is {datadir}/base */
     121      297632 :         return psprintf("base/%u", dbOid);
     122             :     }
     123             :     else
     124             :     {
     125             :         /* All other tablespaces are accessed via symlinks */
     126        2754 :         return psprintf("pg_tblspc/%u/%s/%u",
     127             :                         spcOid, TABLESPACE_VERSION_DIRECTORY, dbOid);
     128             :     }
     129             : }
     130             : 
     131             : /*
     132             :  * GetRelationPath - construct path to a relation's file
     133             :  *
     134             :  * Result is a palloc'd string.
     135             :  *
     136             :  * Note: ideally, procNumber would be declared as type ProcNumber, but
     137             :  * relpath.h would have to include a backend-only header to do that; doesn't
     138             :  * seem worth the trouble considering ProcNumber is just int anyway.
     139             :  */
     140             : char *
     141     2750036 : GetRelationPath(Oid dbOid, Oid spcOid, RelFileNumber relNumber,
     142             :                 int procNumber, ForkNumber forkNumber)
     143             : {
     144             :     char       *path;
     145             : 
     146     2750036 :     if (spcOid == GLOBALTABLESPACE_OID)
     147             :     {
     148             :         /* Shared system relations live in {datadir}/global */
     149             :         Assert(dbOid == 0);
     150             :         Assert(procNumber == INVALID_PROC_NUMBER);
     151      104604 :         if (forkNumber != MAIN_FORKNUM)
     152       19760 :             path = psprintf("global/%u_%s",
     153             :                             relNumber, forkNames[forkNumber]);
     154             :         else
     155       84844 :             path = psprintf("global/%u", relNumber);
     156             :     }
     157     2645432 :     else if (spcOid == DEFAULTTABLESPACE_OID)
     158             :     {
     159             :         /* The default tablespace is {datadir}/base */
     160     2635588 :         if (procNumber == INVALID_PROC_NUMBER)
     161             :         {
     162     2582124 :             if (forkNumber != MAIN_FORKNUM)
     163     1039144 :                 path = psprintf("base/%u/%u_%s",
     164             :                                 dbOid, relNumber,
     165             :                                 forkNames[forkNumber]);
     166             :             else
     167     1542980 :                 path = psprintf("base/%u/%u",
     168             :                                 dbOid, relNumber);
     169             :         }
     170             :         else
     171             :         {
     172       53464 :             if (forkNumber != MAIN_FORKNUM)
     173       28044 :                 path = psprintf("base/%u/t%d_%u_%s",
     174             :                                 dbOid, procNumber, relNumber,
     175             :                                 forkNames[forkNumber]);
     176             :             else
     177       25420 :                 path = psprintf("base/%u/t%d_%u",
     178             :                                 dbOid, procNumber, relNumber);
     179             :         }
     180             :     }
     181             :     else
     182             :     {
     183             :         /* All other tablespaces are accessed via symlinks */
     184        9844 :         if (procNumber == INVALID_PROC_NUMBER)
     185             :         {
     186        9730 :             if (forkNumber != MAIN_FORKNUM)
     187        4328 :                 path = psprintf("pg_tblspc/%u/%s/%u/%u_%s",
     188             :                                 spcOid, TABLESPACE_VERSION_DIRECTORY,
     189             :                                 dbOid, relNumber,
     190             :                                 forkNames[forkNumber]);
     191             :             else
     192        5402 :                 path = psprintf("pg_tblspc/%u/%s/%u/%u",
     193             :                                 spcOid, TABLESPACE_VERSION_DIRECTORY,
     194             :                                 dbOid, relNumber);
     195             :         }
     196             :         else
     197             :         {
     198         114 :             if (forkNumber != MAIN_FORKNUM)
     199          60 :                 path = psprintf("pg_tblspc/%u/%s/%u/t%d_%u_%s",
     200             :                                 spcOid, TABLESPACE_VERSION_DIRECTORY,
     201             :                                 dbOid, procNumber, relNumber,
     202             :                                 forkNames[forkNumber]);
     203             :             else
     204          54 :                 path = psprintf("pg_tblspc/%u/%s/%u/t%d_%u",
     205             :                                 spcOid, TABLESPACE_VERSION_DIRECTORY,
     206             :                                 dbOid, procNumber, relNumber);
     207             :         }
     208             :     }
     209     2750036 :     return path;
     210             : }

Generated by: LCOV version 1.14