relpath.c File Reference

#include "postgres.h"
#include "catalog/pg_tablespace_d.h"
#include "common/relpath.h"
#include "storage/procnumber.h"

Include dependency graph for relpath.c:

Go to the source code of this file.

Functions
	StaticAssertDecl (lengthof(forkNames)==(MAX_FORKNUM+1), "array length mismatch")
ForkNumber	forkname_to_number (const char *forkName)
int	forkname_chars (const char *str, ForkNumber *fork)
char *	GetDatabasePath (Oid dbOid, Oid spcOid)
RelPathStr	GetRelationPath (Oid dbOid, Oid spcOid, RelFileNumber relNumber, int procNumber, ForkNumber forkNumber)

Variables
const char *const	forkNames []

Function Documentation

forkname_chars()

int forkname_chars	(	const char *	str,
		ForkNumber *	fork
	)

Definition at line 81 of file relpath.c.

{
    ForkNumber  forkNum;
 
    for (forkNum = 1; forkNum <= MAX_FORKNUM; forkNum++)
    {
        int         len = strlen(forkNames[forkNum]);
 
        if (strncmp(forkNames[forkNum], str, len) == 0)
        {
            if (fork)
                *fork = forkNum;
            return len;
        }
    }
    if (fork)
        *fork = InvalidForkNumber;
    return 0;
}

References forkNames, InvalidForkNumber, len, MAX_FORKNUM, and str.

Referenced by looks_like_temp_rel_name(), and parse_filename_for_nontemp_relation().

forkname_to_number()

ForkNumber forkname_to_number

(

const char *

forkName

)

Definition at line 50 of file relpath.c.

{
    ForkNumber  forkNum;
 
    for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
        if (strcmp(forkNames[forkNum], forkName) == 0)
            return forkNum;
 
#ifndef FRONTEND
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("invalid fork name"),
             errhint("Valid fork names are \"main\", \"fsm\", "
                     "\"vm\", and \"init\".")));
#endif
 
    return InvalidForkNumber;
}

References ereport, errcode(), errhint(), errmsg(), ERROR, forkNames, InvalidForkNumber, and MAX_FORKNUM.

Referenced by get_raw_page_fork(), get_raw_page_fork_1_9(), main(), pg_prewarm(), and pg_relation_size().

GetDatabasePath()

char * GetDatabasePath	(	Oid	dbOid,
		Oid	spcOid
	)

Definition at line 110 of file relpath.c.

{
    if (spcOid == GLOBALTABLESPACE_OID)
    {
        /* Shared system relations live in {datadir}/global */
        Assert(dbOid == 0);
        return pstrdup("global");
    }
    else if (spcOid == DEFAULTTABLESPACE_OID)
    {
        /* The default tablespace is {datadir}/base */
        return psprintf("base/%u", dbOid);
    }
    else
    {
        /* All other tablespaces are accessed via symlinks */
        return psprintf("%s/%u/%s/%u",
                        PG_TBLSPC_DIR, spcOid,
                        TABLESPACE_VERSION_DIRECTORY, dbOid);
    }
}

References Assert(), PG_TBLSPC_DIR, psprintf(), pstrdup(), and TABLESPACE_VERSION_DIRECTORY.

Referenced by check_db_file_conflict(), CreateDatabaseUsingFileCopy(), CreateDatabaseUsingWalLog(), createdb(), dbase_redo(), InitPostgres(), movedb(), movedb_failure_callback(), ProcessCommittedInvalidationMessages(), relmap_redo(), remove_dbtablespaces(), and TablespaceCreateDbspace().

GetRelationPath()

RelPathStr GetRelationPath	(	Oid	dbOid,
		Oid	spcOid,
		RelFileNumber	relNumber,
		int	procNumber,
		ForkNumber	forkNumber
	)

Definition at line 143 of file relpath.c.

{
    RelPathStr  rp;
 
    if (spcOid == GLOBALTABLESPACE_OID)
    {
        /* Shared system relations live in {datadir}/global */
        Assert(dbOid == 0);
        Assert(procNumber == INVALID_PROC_NUMBER);
        if (forkNumber != MAIN_FORKNUM)
            sprintf(rp.str, "global/%u_%s",
                    relNumber, forkNames[forkNumber]);
        else
            sprintf(rp.str, "global/%u",
                    relNumber);
    }
    else if (spcOid == DEFAULTTABLESPACE_OID)
    {
        /* The default tablespace is {datadir}/base */
        if (procNumber == INVALID_PROC_NUMBER)
        {
            if (forkNumber != MAIN_FORKNUM)
            {
                sprintf(rp.str, "base/%u/%u_%s",
                        dbOid, relNumber,
                        forkNames[forkNumber]);
            }
            else
                sprintf(rp.str, "base/%u/%u",
                        dbOid, relNumber);
        }
        else
        {
            if (forkNumber != MAIN_FORKNUM)
                sprintf(rp.str, "base/%u/t%d_%u_%s",
                        dbOid, procNumber, relNumber,
                        forkNames[forkNumber]);
            else
                sprintf(rp.str, "base/%u/t%d_%u",
                        dbOid, procNumber, relNumber);
        }
    }
    else
    {
        /* All other tablespaces are accessed via symlinks */
        if (procNumber == INVALID_PROC_NUMBER)
        {
            if (forkNumber != MAIN_FORKNUM)
                sprintf(rp.str, "%s/%u/%s/%u/%u_%s",
                        PG_TBLSPC_DIR, spcOid,
                        TABLESPACE_VERSION_DIRECTORY,
                        dbOid, relNumber,
                        forkNames[forkNumber]);
            else
                sprintf(rp.str, "%s/%u/%s/%u/%u",
                        PG_TBLSPC_DIR, spcOid,
                        TABLESPACE_VERSION_DIRECTORY,
                        dbOid, relNumber);
        }
        else
        {
            if (forkNumber != MAIN_FORKNUM)
                sprintf(rp.str, "%s/%u/%s/%u/t%d_%u_%s",
                        PG_TBLSPC_DIR, spcOid,
                        TABLESPACE_VERSION_DIRECTORY,
                        dbOid, procNumber, relNumber,
                        forkNames[forkNumber]);
            else
                sprintf(rp.str, "%s/%u/%s/%u/t%d_%u",
                        PG_TBLSPC_DIR, spcOid,
                        TABLESPACE_VERSION_DIRECTORY,
                        dbOid, procNumber, relNumber);
        }
    }
 
    Assert(strnlen(rp.str, REL_PATH_STR_MAXLEN + 1) <= REL_PATH_STR_MAXLEN);
 
    return rp;
}

References Assert(), forkNames, INVALID_PROC_NUMBER, MAIN_FORKNUM, PG_TBLSPC_DIR, REL_PATH_STR_MAXLEN, sprintf, RelPathStr::str, strnlen(), and TABLESPACE_VERSION_DIRECTORY.

Referenced by GetIncrementalFilePath(), and test_relpath().

StaticAssertDecl()

StaticAssertDecl	(	lengthof(forkNames)	= =(MAX_FORKNUM+1),
		"array length mismatch"
	)

Variable Documentation

forkNames

const char* const forkNames[]

Initial value:

= {
    [MAIN_FORKNUM] = "main",
    [FSM_FORKNUM] = "fsm",
    [VISIBILITYMAP_FORKNUM] = "vm",
    [INIT_FORKNUM] = "init",
}

Definition at line 33 of file relpath.c.

Referenced by dump_one_relation(), forkname_chars(), forkname_to_number(), GetRelationPath(), XLogRecGetBlockRefInfo(), and XLogRecordSaveFPWs().