dbsize.c File Reference

#include "postgres.h"
#include <sys/stat.h>
#include "access/htup_details.h"
#include "access/relation.h"
#include "catalog/namespace.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_database.h"
#include "catalog/pg_tablespace.h"
#include "commands/dbcommands.h"
#include "commands/tablespace.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/numeric.h"
#include "utils/rel.h"
#include "utils/relfilenumbermap.h"
#include "utils/relmapper.h"
#include "utils/syscache.h"

Include dependency graph for dbsize.c:

Go to the source code of this file.

Data Structures
struct	size_pretty_unit
struct	size_bytes_unit_alias

Macros
#define	half_rounded(x)   (((x) + ((x) < 0 ? -1 : 1)) / 2)

Functions
static int64	db_dir_size (const char *path)
static int64	calculate_database_size (Oid dbOid)
Datum	pg_database_size_oid (PG_FUNCTION_ARGS)
Datum	pg_database_size_name (PG_FUNCTION_ARGS)
static int64	calculate_tablespace_size (Oid tblspcOid)
Datum	pg_tablespace_size_oid (PG_FUNCTION_ARGS)
Datum	pg_tablespace_size_name (PG_FUNCTION_ARGS)
static int64	calculate_relation_size (RelFileLocator *rfn, ProcNumber backend, ForkNumber forknum)
Datum	pg_relation_size (PG_FUNCTION_ARGS)
static int64	calculate_toast_table_size (Oid toastrelid)
static int64	calculate_table_size (Relation rel)
static int64	calculate_indexes_size (Relation rel)
Datum	pg_table_size (PG_FUNCTION_ARGS)
Datum	pg_indexes_size (PG_FUNCTION_ARGS)
static int64	calculate_total_relation_size (Relation rel)
Datum	pg_total_relation_size (PG_FUNCTION_ARGS)
Datum	pg_size_pretty (PG_FUNCTION_ARGS)
static char *	numeric_to_cstring (Numeric n)
static bool	numeric_is_less (Numeric a, Numeric b)
static Numeric	numeric_absolute (Numeric n)
static Numeric	numeric_half_rounded (Numeric n)
static Numeric	numeric_truncated_divide (Numeric n, int64 divisor)
Datum	pg_size_pretty_numeric (PG_FUNCTION_ARGS)
Datum	pg_size_bytes (PG_FUNCTION_ARGS)
Datum	pg_relation_filenode (PG_FUNCTION_ARGS)
Datum	pg_filenode_relation (PG_FUNCTION_ARGS)
Datum	pg_relation_filepath (PG_FUNCTION_ARGS)

Variables
static const struct size_pretty_unit	size_pretty_units []
static const struct size_bytes_unit_alias	size_bytes_aliases []

Macro Definition Documentation

half_rounded

#define half_rounded

(

x

)

(((x) + ((x) < 0 ? -1 : 1)) / 2)

Definition at line 35 of file dbsize.c.

Function Documentation

calculate_database_size()

static int64 calculate_database_size ( Oid  dbOid )

static

Definition at line 118 of file dbsize.c.

{
    int64       totalsize;
    DIR        *dirdesc;
    struct dirent *direntry;
    char        dirpath[MAXPGPATH];
    char        pathname[MAXPGPATH + 21 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
    AclResult   aclresult;
 
    /*
     * User must have connect privilege for target database or have privileges
     * of pg_read_all_stats
     */
    aclresult = object_aclcheck(DatabaseRelationId, dbOid, GetUserId(), ACL_CONNECT);
    if (aclresult != ACLCHECK_OK &&
        !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS))
    {
        aclcheck_error(aclresult, OBJECT_DATABASE,
                       get_database_name(dbOid));
    }
 
    /* Shared storage in pg_global is not counted */
 
    /* Include pg_default storage */
    snprintf(pathname, sizeof(pathname), "base/%u", dbOid);
    totalsize = db_dir_size(pathname);
 
    /* Scan the non-default tablespaces */
    snprintf(dirpath, MAXPGPATH, PG_TBLSPC_DIR);
    dirdesc = AllocateDir(dirpath);
 
    while ((direntry = ReadDir(dirdesc, dirpath)) != NULL)
    {
        CHECK_FOR_INTERRUPTS();
 
        if (strcmp(direntry->d_name, ".") == 0 ||
            strcmp(direntry->d_name, "..") == 0)
            continue;
 
        snprintf(pathname, sizeof(pathname), "%s/%s/%s/%u",
                 PG_TBLSPC_DIR, direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid);
        totalsize += db_dir_size(pathname);
    }
 
    FreeDir(dirdesc);
 
    return totalsize;
}

References ACL_CONNECT, aclcheck_error(), ACLCHECK_OK, AllocateDir(), CHECK_FOR_INTERRUPTS, dirent::d_name, db_dir_size(), FreeDir(), get_database_name(), GetUserId(), has_privs_of_role(), MAXPGPATH, object_aclcheck(), OBJECT_DATABASE, PG_TBLSPC_DIR, ReadDir(), snprintf, and TABLESPACE_VERSION_DIRECTORY.

Referenced by pg_database_size_name(), and pg_database_size_oid().

calculate_indexes_size()

static int64 calculate_indexes_size ( Relation  rel )

static

Definition at line 469 of file dbsize.c.

{
    int64       size = 0;
 
    /*
     * Aggregate all indexes on the given relation
     */
    if (rel->rd_rel->relhasindex)
    {
        List       *index_oids = RelationGetIndexList(rel);
        ListCell   *cell;
 
        foreach(cell, index_oids)
        {
            Oid         idxOid = lfirst_oid(cell);
            Relation    idxRel;
            ForkNumber  forkNum;
 
            idxRel = relation_open(idxOid, AccessShareLock);
 
            for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
                size += calculate_relation_size(&(idxRel->rd_locator),
                                                idxRel->rd_backend,
                                                forkNum);
 
            relation_close(idxRel, AccessShareLock);
        }
 
        list_free(index_oids);
    }
 
    return size;
}

References AccessShareLock, calculate_relation_size(), lfirst_oid, list_free(), MAX_FORKNUM, RelationData::rd_backend, RelationData::rd_locator, RelationData::rd_rel, relation_close(), relation_open(), and RelationGetIndexList().

Referenced by calculate_total_relation_size(), and pg_indexes_size().

calculate_relation_size()

static int64 calculate_relation_size ( RelFileLocator *  rfn, ProcNumber  backend, ForkNumber  forknum  )

static

Definition at line 326 of file dbsize.c.

{
    int64       totalsize = 0;
    RelPathStr  relationpath;
    char        pathname[MAXPGPATH];
    unsigned int segcount = 0;
 
    relationpath = relpathbackend(*rfn, backend, forknum);
 
    for (segcount = 0;; segcount++)
    {
        struct stat fst;
 
        CHECK_FOR_INTERRUPTS();
 
        if (segcount == 0)
            snprintf(pathname, MAXPGPATH, "%s",
                     relationpath.str);
        else
            snprintf(pathname, MAXPGPATH, "%s.%u",
                     relationpath.str, segcount);
 
        if (stat(pathname, &fst) < 0)
        {
            if (errno == ENOENT)
                break;
            else
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not stat file \"%s\": %m", pathname)));
        }
        totalsize += fst.st_size;
    }
 
    return totalsize;
}

References CHECK_FOR_INTERRUPTS, ereport, errcode_for_file_access(), errmsg(), ERROR, MAXPGPATH, relpathbackend, snprintf, stat::st_size, stat, and RelPathStr::str.

Referenced by calculate_indexes_size(), calculate_table_size(), calculate_toast_table_size(), and pg_relation_size().

calculate_table_size()

static int64 calculate_table_size ( Relation  rel )

static

Definition at line 442 of file dbsize.c.

{
    int64       size = 0;
    ForkNumber  forkNum;
 
    /*
     * heap size, including FSM and VM
     */
    for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
        size += calculate_relation_size(&(rel->rd_locator), rel->rd_backend,
                                        forkNum);
 
    /*
     * Size of toast relation
     */
    if (OidIsValid(rel->rd_rel->reltoastrelid))
        size += calculate_toast_table_size(rel->rd_rel->reltoastrelid);
 
    return size;
}

References calculate_relation_size(), calculate_toast_table_size(), MAX_FORKNUM, OidIsValid, RelationData::rd_backend, RelationData::rd_locator, and RelationData::rd_rel.

Referenced by calculate_total_relation_size(), and pg_table_size().

calculate_tablespace_size()

static int64 calculate_tablespace_size ( Oid  tblspcOid )

static

Definition at line 211 of file dbsize.c.

{
    char        tblspcPath[MAXPGPATH];
    char        pathname[MAXPGPATH * 2];
    int64       totalsize = 0;
    DIR        *dirdesc;
    struct dirent *direntry;
    AclResult   aclresult;
 
    /*
     * User must have privileges of pg_read_all_stats or have CREATE privilege
     * for target tablespace, either explicitly granted or implicitly because
     * it is default for current database.
     */
    if (tblspcOid != MyDatabaseTableSpace &&
        !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_STATS))
    {
        aclresult = object_aclcheck(TableSpaceRelationId, tblspcOid, GetUserId(), ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE,
                           get_tablespace_name(tblspcOid));
    }
 
    if (tblspcOid == DEFAULTTABLESPACE_OID)
        snprintf(tblspcPath, MAXPGPATH, "base");
    else if (tblspcOid == GLOBALTABLESPACE_OID)
        snprintf(tblspcPath, MAXPGPATH, "global");
    else
        snprintf(tblspcPath, MAXPGPATH, "%s/%u/%s", PG_TBLSPC_DIR, tblspcOid,
                 TABLESPACE_VERSION_DIRECTORY);
 
    dirdesc = AllocateDir(tblspcPath);
 
    if (!dirdesc)
        return -1;
 
    while ((direntry = ReadDir(dirdesc, tblspcPath)) != NULL)
    {
        struct stat fst;
 
        CHECK_FOR_INTERRUPTS();
 
        if (strcmp(direntry->d_name, ".") == 0 ||
            strcmp(direntry->d_name, "..") == 0)
            continue;
 
        snprintf(pathname, sizeof(pathname), "%s/%s", tblspcPath, direntry->d_name);
 
        if (stat(pathname, &fst) < 0)
        {
            if (errno == ENOENT)
                continue;
            else
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not stat file \"%s\": %m", pathname)));
        }
 
        if (S_ISDIR(fst.st_mode))
            totalsize += db_dir_size(pathname);
 
        totalsize += fst.st_size;
    }
 
    FreeDir(dirdesc);
 
    return totalsize;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, AllocateDir(), CHECK_FOR_INTERRUPTS, dirent::d_name, db_dir_size(), ereport, errcode_for_file_access(), errmsg(), ERROR, FreeDir(), get_tablespace_name(), GetUserId(), has_privs_of_role(), MAXPGPATH, MyDatabaseTableSpace, object_aclcheck(), OBJECT_TABLESPACE, PG_TBLSPC_DIR, ReadDir(), S_ISDIR, snprintf, stat::st_mode, stat::st_size, stat, and TABLESPACE_VERSION_DIRECTORY.

Referenced by pg_tablespace_size_name(), and pg_tablespace_size_oid().

calculate_toast_table_size()

static int64 calculate_toast_table_size ( Oid  toastrelid )

static

Definition at line 396 of file dbsize.c.

{
    int64       size = 0;
    Relation    toastRel;
    ForkNumber  forkNum;
    ListCell   *lc;
    List       *indexlist;
 
    toastRel = relation_open(toastrelid, AccessShareLock);
 
    /* toast heap size, including FSM and VM size */
    for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
        size += calculate_relation_size(&(toastRel->rd_locator),
                                        toastRel->rd_backend, forkNum);
 
    /* toast index size, including FSM and VM size */
    indexlist = RelationGetIndexList(toastRel);
 
    /* Size is calculated using all the indexes available */
    foreach(lc, indexlist)
    {
        Relation    toastIdxRel;
 
        toastIdxRel = relation_open(lfirst_oid(lc),
                                    AccessShareLock);
        for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
            size += calculate_relation_size(&(toastIdxRel->rd_locator),
                                            toastIdxRel->rd_backend, forkNum);
 
        relation_close(toastIdxRel, AccessShareLock);
    }
    list_free(indexlist);
    relation_close(toastRel, AccessShareLock);
 
    return size;
}

References AccessShareLock, calculate_relation_size(), lfirst_oid, list_free(), MAX_FORKNUM, RelationData::rd_backend, RelationData::rd_locator, relation_close(), relation_open(), and RelationGetIndexList().

Referenced by calculate_table_size().

calculate_total_relation_size()

static int64 calculate_total_relation_size ( Relation  rel )

static

Definition at line 546 of file dbsize.c.

{
    int64       size;
 
    /*
     * Aggregate the table size, this includes size of the heap, toast and
     * toast index with free space and visibility map
     */
    size = calculate_table_size(rel);
 
    /*
     * Add size of all attached indexes as well
     */
    size += calculate_indexes_size(rel);
 
    return size;
}

References calculate_indexes_size(), and calculate_table_size().

Referenced by pg_total_relation_size().

db_dir_size()

static int64 db_dir_size ( const char *  path )

static

Definition at line 74 of file dbsize.c.

{
    int64       dirsize = 0;
    struct dirent *direntry;
    DIR        *dirdesc;
    char        filename[MAXPGPATH * 2];
 
    dirdesc = AllocateDir(path);
 
    if (!dirdesc)
        return 0;
 
    while ((direntry = ReadDir(dirdesc, path)) != NULL)
    {
        struct stat fst;
 
        CHECK_FOR_INTERRUPTS();
 
        if (strcmp(direntry->d_name, ".") == 0 ||
            strcmp(direntry->d_name, "..") == 0)
            continue;
 
        snprintf(filename, sizeof(filename), "%s/%s", path, direntry->d_name);
 
        if (stat(filename, &fst) < 0)
        {
            if (errno == ENOENT)
                continue;
            else
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not stat file \"%s\": %m", filename)));
        }
        dirsize += fst.st_size;
    }
 
    FreeDir(dirdesc);
    return dirsize;
}

References AllocateDir(), CHECK_FOR_INTERRUPTS, dirent::d_name, ereport, errcode_for_file_access(), errmsg(), ERROR, filename, FreeDir(), MAXPGPATH, ReadDir(), snprintf, stat::st_size, and stat.

Referenced by calculate_database_size(), and calculate_tablespace_size().

numeric_absolute()

static Numeric numeric_absolute ( Numeric  n )

static

Definition at line 646 of file dbsize.c.

{
    Datum       d = NumericGetDatum(n);
    Datum       result;
 
    result = DirectFunctionCall1(numeric_abs, d);
    return DatumGetNumeric(result);
}

References DatumGetNumeric(), DirectFunctionCall1, numeric_abs(), and NumericGetDatum().

Referenced by pg_size_pretty_numeric().

numeric_half_rounded()

static Numeric numeric_half_rounded ( Numeric  n )

static

Definition at line 656 of file dbsize.c.

{
    Datum       d = NumericGetDatum(n);
    Datum       zero;
    Datum       one;
    Datum       two;
    Datum       result;
 
    zero = NumericGetDatum(int64_to_numeric(0));
    one = NumericGetDatum(int64_to_numeric(1));
    two = NumericGetDatum(int64_to_numeric(2));
 
    if (DatumGetBool(DirectFunctionCall2(numeric_ge, d, zero)))
        d = DirectFunctionCall2(numeric_add, d, one);
    else
        d = DirectFunctionCall2(numeric_sub, d, one);
 
    result = DirectFunctionCall2(numeric_div_trunc, d, two);
    return DatumGetNumeric(result);
}

References DatumGetBool(), DatumGetNumeric(), DirectFunctionCall2, int64_to_numeric(), numeric_add(), numeric_div_trunc(), numeric_ge(), numeric_sub(), and NumericGetDatum().

Referenced by pg_size_pretty_numeric().

numeric_is_less()

static bool numeric_is_less ( Numeric  a, Numeric  b  )

static

Definition at line 637 of file dbsize.c.

{
    Datum       da = NumericGetDatum(a);
    Datum       db = NumericGetDatum(b);
 
    return DatumGetBool(DirectFunctionCall2(numeric_lt, da, db));
}

References a, b, DatumGetBool(), DirectFunctionCall2, numeric_lt(), and NumericGetDatum().

Referenced by pg_size_pretty_numeric().

numeric_to_cstring()

static char * numeric_to_cstring ( Numeric  n )

static

Definition at line 629 of file dbsize.c.

{
    Datum       d = NumericGetDatum(n);
 
    return DatumGetCString(DirectFunctionCall1(numeric_out, d));
}

References DatumGetCString(), DirectFunctionCall1, numeric_out(), and NumericGetDatum().

Referenced by pg_size_pretty_numeric().

numeric_truncated_divide()

static Numeric numeric_truncated_divide ( Numeric  n, int64  divisor  )

static

Definition at line 678 of file dbsize.c.

{
    Datum       d = NumericGetDatum(n);
    Datum       divisor_numeric;
    Datum       result;
 
    divisor_numeric = NumericGetDatum(int64_to_numeric(divisor));
    result = DirectFunctionCall2(numeric_div_trunc, d, divisor_numeric);
    return DatumGetNumeric(result);
}

References DatumGetNumeric(), DirectFunctionCall2, int64_to_numeric(), numeric_div_trunc(), and NumericGetDatum().

Referenced by pg_size_pretty_numeric().

pg_database_size_name()

Datum pg_database_size_name

(

PG_FUNCTION_ARGS

)

Definition at line 191 of file dbsize.c.

{
    Name        dbName = PG_GETARG_NAME(0);
    Oid         dbOid = get_database_oid(NameStr(*dbName), false);
    int64       size;
 
    size = calculate_database_size(dbOid);
 
    if (size == 0)
        PG_RETURN_NULL();
 
    PG_RETURN_INT64(size);
}

References calculate_database_size(), dbName, get_database_oid(), NameStr, PG_GETARG_NAME, PG_RETURN_INT64, and PG_RETURN_NULL.

pg_database_size_oid()

Datum pg_database_size_oid

(

PG_FUNCTION_ARGS

)

Definition at line 168 of file dbsize.c.

{
    Oid         dbOid = PG_GETARG_OID(0);
    int64       size;
 
    /*
     * Not needed for correctness, but avoid non-user-facing error message
     * later if the database doesn't exist.
     */
    if (!SearchSysCacheExists1(DATABASEOID, ObjectIdGetDatum(dbOid)))
        ereport(ERROR,
                errcode(ERRCODE_UNDEFINED_OBJECT),
                errmsg("database with OID %u does not exist", dbOid));
 
    size = calculate_database_size(dbOid);
 
    if (size == 0)
        PG_RETURN_NULL();
 
    PG_RETURN_INT64(size);
}

References calculate_database_size(), ereport, errcode(), errmsg(), ERROR, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, and SearchSysCacheExists1.

pg_filenode_relation()

Datum pg_filenode_relation

(

PG_FUNCTION_ARGS

)

Definition at line 945 of file dbsize.c.

{
    Oid         reltablespace = PG_GETARG_OID(0);
    RelFileNumber relfilenumber = PG_GETARG_OID(1);
    Oid         heaprel;
 
    /* test needed so RelidByRelfilenumber doesn't misbehave */
    if (!RelFileNumberIsValid(relfilenumber))
        PG_RETURN_NULL();
 
    heaprel = RelidByRelfilenumber(reltablespace, relfilenumber);
 
    if (!OidIsValid(heaprel))
        PG_RETURN_NULL();
    else
        PG_RETURN_OID(heaprel);
}

References OidIsValid, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_OID, RelFileNumberIsValid, and RelidByRelfilenumber().

pg_indexes_size()

Datum pg_indexes_size

(

PG_FUNCTION_ARGS

)

Definition at line 523 of file dbsize.c.

{
    Oid         relOid = PG_GETARG_OID(0);
    Relation    rel;
    int64       size;
 
    rel = try_relation_open(relOid, AccessShareLock);
 
    if (rel == NULL)
        PG_RETURN_NULL();
 
    size = calculate_indexes_size(rel);
 
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_INT64(size);
}

References AccessShareLock, calculate_indexes_size(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, relation_close(), and try_relation_open().

pg_relation_filenode()

Datum pg_relation_filenode

(

PG_FUNCTION_ARGS

)

Definition at line 897 of file dbsize.c.

{
    Oid         relid = PG_GETARG_OID(0);
    RelFileNumber result;
    HeapTuple   tuple;
    Form_pg_class relform;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        PG_RETURN_NULL();
    relform = (Form_pg_class) GETSTRUCT(tuple);
 
    if (RELKIND_HAS_STORAGE(relform->relkind))
    {
        if (relform->relfilenode)
            result = relform->relfilenode;
        else                    /* Consult the relation mapper */
            result = RelationMapOidToFilenumber(relid,
                                                relform->relisshared);
    }
    else
    {
        /* no storage, return NULL */
        result = InvalidRelFileNumber;
    }
 
    ReleaseSysCache(tuple);
 
    if (!RelFileNumberIsValid(result))
        PG_RETURN_NULL();
 
    PG_RETURN_OID(result);
}

References GETSTRUCT(), HeapTupleIsValid, InvalidRelFileNumber, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_OID, RelationMapOidToFilenumber(), ReleaseSysCache(), RelFileNumberIsValid, and SearchSysCache1().

pg_relation_filepath()

Datum pg_relation_filepath

(

PG_FUNCTION_ARGS

)

Definition at line 969 of file dbsize.c.

{
    Oid         relid = PG_GETARG_OID(0);
    HeapTuple   tuple;
    Form_pg_class relform;
    RelFileLocator rlocator;
    ProcNumber  backend;
    RelPathStr  path;
 
    tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(tuple))
        PG_RETURN_NULL();
    relform = (Form_pg_class) GETSTRUCT(tuple);
 
    if (RELKIND_HAS_STORAGE(relform->relkind))
    {
        /* This logic should match RelationInitPhysicalAddr */
        if (relform->reltablespace)
            rlocator.spcOid = relform->reltablespace;
        else
            rlocator.spcOid = MyDatabaseTableSpace;
        if (rlocator.spcOid == GLOBALTABLESPACE_OID)
            rlocator.dbOid = InvalidOid;
        else
            rlocator.dbOid = MyDatabaseId;
        if (relform->relfilenode)
            rlocator.relNumber = relform->relfilenode;
        else                    /* Consult the relation mapper */
            rlocator.relNumber = RelationMapOidToFilenumber(relid,
                                                            relform->relisshared);
    }
    else
    {
        /* no storage, return NULL */
        rlocator.relNumber = InvalidRelFileNumber;
        /* some compilers generate warnings without these next two lines */
        rlocator.dbOid = InvalidOid;
        rlocator.spcOid = InvalidOid;
    }
 
    if (!RelFileNumberIsValid(rlocator.relNumber))
    {
        ReleaseSysCache(tuple);
        PG_RETURN_NULL();
    }
 
    /* Determine owning backend. */
    switch (relform->relpersistence)
    {
        case RELPERSISTENCE_UNLOGGED:
        case RELPERSISTENCE_PERMANENT:
            backend = INVALID_PROC_NUMBER;
            break;
        case RELPERSISTENCE_TEMP:
            if (isTempOrTempToastNamespace(relform->relnamespace))
                backend = ProcNumberForTempRelations();
            else
            {
                /* Do it the hard way. */
                backend = GetTempNamespaceProcNumber(relform->relnamespace);
                Assert(backend != INVALID_PROC_NUMBER);
            }
            break;
        default:
            elog(ERROR, "invalid relpersistence: %c", relform->relpersistence);
            backend = INVALID_PROC_NUMBER;  /* placate compiler */
            break;
    }
 
    ReleaseSysCache(tuple);
 
    path = relpathbackend(rlocator, backend, MAIN_FORKNUM);
 
    PG_RETURN_TEXT_P(cstring_to_text(path.str));
}

References Assert(), cstring_to_text(), RelFileLocator::dbOid, elog, ERROR, GETSTRUCT(), GetTempNamespaceProcNumber(), HeapTupleIsValid, INVALID_PROC_NUMBER, InvalidOid, InvalidRelFileNumber, isTempOrTempToastNamespace(), MAIN_FORKNUM, MyDatabaseId, MyDatabaseTableSpace, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_TEXT_P, ProcNumberForTempRelations, RelationMapOidToFilenumber(), ReleaseSysCache(), RelFileNumberIsValid, RelFileLocator::relNumber, relpathbackend, SearchSysCache1(), RelFileLocator::spcOid, and RelPathStr::str.

pg_relation_size()

Datum pg_relation_size

(

PG_FUNCTION_ARGS

)

Definition at line 364 of file dbsize.c.

{
    Oid         relOid = PG_GETARG_OID(0);
    text       *forkName = PG_GETARG_TEXT_PP(1);
    Relation    rel;
    int64       size;
 
    rel = try_relation_open(relOid, AccessShareLock);
 
    /*
     * Before 9.2, we used to throw an error if the relation didn't exist, but
     * that makes queries like "SELECT pg_relation_size(oid) FROM pg_class"
     * less robust, because while we scan pg_class with an MVCC snapshot,
     * someone else might drop the table. It's better to return NULL for
     * already-dropped tables than throw an error and abort the whole query.
     */
    if (rel == NULL)
        PG_RETURN_NULL();
 
    size = calculate_relation_size(&(rel->rd_locator), rel->rd_backend,
                                   forkname_to_number(text_to_cstring(forkName)));
 
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_INT64(size);
}

References AccessShareLock, calculate_relation_size(), forkname_to_number(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_INT64, PG_RETURN_NULL, RelationData::rd_backend, RelationData::rd_locator, relation_close(), text_to_cstring(), and try_relation_open().

pg_size_bytes()

Datum pg_size_bytes

(

PG_FUNCTION_ARGS

)

Definition at line 731 of file dbsize.c.

{
    text       *arg = PG_GETARG_TEXT_PP(0);
    char       *str,
               *strptr,
               *endptr;
    char        saved_char;
    Numeric     num;
    int64       result;
    bool        have_digits = false;
 
    str = text_to_cstring(arg);
 
    /* Skip leading whitespace */
    strptr = str;
    while (isspace((unsigned char) *strptr))
        strptr++;
 
    /* Check that we have a valid number and determine where it ends */
    endptr = strptr;
 
    /* Part (1): sign */
    if (*endptr == '-' || *endptr == '+')
        endptr++;
 
    /* Part (2): main digit string */
    if (isdigit((unsigned char) *endptr))
    {
        have_digits = true;
        do
            endptr++;
        while (isdigit((unsigned char) *endptr));
    }
 
    /* Part (3): optional decimal point and fractional digits */
    if (*endptr == '.')
    {
        endptr++;
        if (isdigit((unsigned char) *endptr))
        {
            have_digits = true;
            do
                endptr++;
            while (isdigit((unsigned char) *endptr));
        }
    }
 
    /* Complain if we don't have a valid number at this point */
    if (!have_digits)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid size: \"%s\"", str)));
 
    /* Part (4): optional exponent */
    if (*endptr == 'e' || *endptr == 'E')
    {
        long        exponent;
        char       *cp;
 
        /*
         * Note we might one day support EB units, so if what follows 'E'
         * isn't a number, just treat it all as a unit to be parsed.
         */
        exponent = strtol(endptr + 1, &cp, 10);
        (void) exponent;        /* Silence -Wunused-result warnings */
        if (cp > endptr + 1)
            endptr = cp;
    }
 
    /*
     * Parse the number, saving the next character, which may be the first
     * character of the unit string.
     */
    saved_char = *endptr;
    *endptr = '\0';
 
    num = DatumGetNumeric(DirectFunctionCall3(numeric_in,
                                              CStringGetDatum(strptr),
                                              ObjectIdGetDatum(InvalidOid),
                                              Int32GetDatum(-1)));
 
    *endptr = saved_char;
 
    /* Skip whitespace between number and unit */
    strptr = endptr;
    while (isspace((unsigned char) *strptr))
        strptr++;
 
    /* Handle possible unit */
    if (*strptr != '\0')
    {
        const struct size_pretty_unit *unit;
        int64       multiplier = 0;
 
        /* Trim any trailing whitespace */
        endptr = str + VARSIZE_ANY_EXHDR(arg) - 1;
 
        while (isspace((unsigned char) *endptr))
            endptr--;
 
        endptr++;
        *endptr = '\0';
 
        for (unit = size_pretty_units; unit->name != NULL; unit++)
        {
            /* Parse the unit case-insensitively */
            if (pg_strcasecmp(strptr, unit->name) == 0)
                break;
        }
 
        /* If not found, look in table of aliases */
        if (unit->name == NULL)
        {
            for (const struct size_bytes_unit_alias *a = size_bytes_aliases; a->alias != NULL; a++)
            {
                if (pg_strcasecmp(strptr, a->alias) == 0)
                {
                    unit = &size_pretty_units[a->unit_index];
                    break;
                }
            }
        }
 
        /* Verify we found a valid unit in the loop above */
        if (unit->name == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid size: \"%s\"", text_to_cstring(arg)),
                     errdetail("Invalid size unit: \"%s\".", strptr),
                     errhint("Valid units are \"bytes\", \"B\", \"kB\", \"MB\", \"GB\", \"TB\", and \"PB\".")));
 
        multiplier = ((int64) 1) << unit->unitbits;
 
        if (multiplier > 1)
        {
            Numeric     mul_num;
 
            mul_num = int64_to_numeric(multiplier);
 
            num = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
                                                      NumericGetDatum(mul_num),
                                                      NumericGetDatum(num)));
        }
    }
 
    result = DatumGetInt64(DirectFunctionCall1(numeric_int8,
                                               NumericGetDatum(num)));
 
    PG_RETURN_INT64(result);
}

References a, arg, CStringGetDatum(), DatumGetInt64(), DatumGetNumeric(), DirectFunctionCall1, DirectFunctionCall2, DirectFunctionCall3, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, Int32GetDatum(), int64_to_numeric(), InvalidOid, size_pretty_unit::name, numeric_in(), numeric_int8(), numeric_mul(), NumericGetDatum(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_RETURN_INT64, pg_strcasecmp(), size_bytes_aliases, size_pretty_units, str, text_to_cstring(), size_pretty_unit::unitbits, and VARSIZE_ANY_EXHDR.

pg_size_pretty()

Datum pg_size_pretty

(

PG_FUNCTION_ARGS

)

Definition at line 587 of file dbsize.c.

{
    int64       size = PG_GETARG_INT64(0);
    char        buf[64];
    const struct size_pretty_unit *unit;
 
    for (unit = size_pretty_units; unit->name != NULL; unit++)
    {
        uint8       bits;
        uint64      abs_size = size < 0 ? 0 - (uint64) size : (uint64) size;
 
        /*
         * Use this unit if there are no more units or the absolute size is
         * below the limit for the current unit.
         */
        if (unit[1].name == NULL || abs_size < unit->limit)
        {
            if (unit->round)
                size = half_rounded(size);
 
            snprintf(buf, sizeof(buf), INT64_FORMAT " %s", size, unit->name);
            break;
        }
 
        /*
         * Determine the number of bits to use to build the divisor.  We may
         * need to use 1 bit less than the difference between this and the
         * next unit if the next unit uses half rounding.  Or we may need to
         * shift an extra bit if this unit uses half rounding and the next one
         * does not.  We use division rather than shifting right by this
         * number of bits to ensure positive and negative values are rounded
         * in the same way.
         */
        bits = (unit[1].unitbits - unit->unitbits - (unit[1].round == true)
                + (unit->round == true));
        size /= ((int64) 1) << bits;
    }
 
    PG_RETURN_TEXT_P(cstring_to_text(buf));
}

References buf, cstring_to_text(), half_rounded, INT64_FORMAT, size_pretty_unit::limit, name, size_pretty_unit::name, PG_GETARG_INT64, PG_RETURN_TEXT_P, size_pretty_unit::round, size_pretty_units, snprintf, and size_pretty_unit::unitbits.

pg_size_pretty_numeric()

Datum pg_size_pretty_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 690 of file dbsize.c.

{
    Numeric     size = PG_GETARG_NUMERIC(0);
    char       *result = NULL;
    const struct size_pretty_unit *unit;
 
    for (unit = size_pretty_units; unit->name != NULL; unit++)
    {
        unsigned int shiftby;
 
        /* use this unit if there are no more units or we're below the limit */
        if (unit[1].name == NULL ||
            numeric_is_less(numeric_absolute(size),
                            int64_to_numeric(unit->limit)))
        {
            if (unit->round)
                size = numeric_half_rounded(size);
 
            result = psprintf("%s %s", numeric_to_cstring(size), unit->name);
            break;
        }
 
        /*
         * Determine the number of bits to use to build the divisor.  We may
         * need to use 1 bit less than the difference between this and the
         * next unit if the next unit uses half rounding.  Or we may need to
         * shift an extra bit if this unit uses half rounding and the next one
         * does not.
         */
        shiftby = (unit[1].unitbits - unit->unitbits - (unit[1].round == true)
                   + (unit->round == true));
        size = numeric_truncated_divide(size, ((int64) 1) << shiftby);
    }
 
    PG_RETURN_TEXT_P(cstring_to_text(result));
}

References cstring_to_text(), int64_to_numeric(), size_pretty_unit::limit, name, size_pretty_unit::name, numeric_absolute(), numeric_half_rounded(), numeric_is_less(), numeric_to_cstring(), numeric_truncated_divide(), PG_GETARG_NUMERIC, PG_RETURN_TEXT_P, psprintf(), size_pretty_unit::round, size_pretty_units, and size_pretty_unit::unitbits.

pg_table_size()

Datum pg_table_size

(

PG_FUNCTION_ARGS

)

Definition at line 504 of file dbsize.c.

{
    Oid         relOid = PG_GETARG_OID(0);
    Relation    rel;
    int64       size;
 
    rel = try_relation_open(relOid, AccessShareLock);
 
    if (rel == NULL)
        PG_RETURN_NULL();
 
    size = calculate_table_size(rel);
 
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_INT64(size);
}

References AccessShareLock, calculate_table_size(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, relation_close(), and try_relation_open().

pg_tablespace_size_name()

Datum pg_tablespace_size_name

(

PG_FUNCTION_ARGS

)

Definition at line 304 of file dbsize.c.

{
    Name        tblspcName = PG_GETARG_NAME(0);
    Oid         tblspcOid = get_tablespace_oid(NameStr(*tblspcName), false);
    int64       size;
 
    size = calculate_tablespace_size(tblspcOid);
 
    if (size < 0)
        PG_RETURN_NULL();
 
    PG_RETURN_INT64(size);
}

References calculate_tablespace_size(), get_tablespace_oid(), NameStr, PG_GETARG_NAME, PG_RETURN_INT64, and PG_RETURN_NULL.

pg_tablespace_size_oid()

Datum pg_tablespace_size_oid

(

PG_FUNCTION_ARGS

)

Definition at line 281 of file dbsize.c.

{
    Oid         tblspcOid = PG_GETARG_OID(0);
    int64       size;
 
    /*
     * Not needed for correctness, but avoid non-user-facing error message
     * later if the tablespace doesn't exist.
     */
    if (!SearchSysCacheExists1(TABLESPACEOID, ObjectIdGetDatum(tblspcOid)))
        ereport(ERROR,
                errcode(ERRCODE_UNDEFINED_OBJECT),
                errmsg("tablespace with OID %u does not exist", tblspcOid));
 
    size = calculate_tablespace_size(tblspcOid);
 
    if (size < 0)
        PG_RETURN_NULL();
 
    PG_RETURN_INT64(size);
}

References calculate_tablespace_size(), ereport, errcode(), errmsg(), ERROR, ObjectIdGetDatum(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, and SearchSysCacheExists1.

pg_total_relation_size()

Datum pg_total_relation_size

(

PG_FUNCTION_ARGS

)

Definition at line 565 of file dbsize.c.

{
    Oid         relOid = PG_GETARG_OID(0);
    Relation    rel;
    int64       size;
 
    rel = try_relation_open(relOid, AccessShareLock);
 
    if (rel == NULL)
        PG_RETURN_NULL();
 
    size = calculate_total_relation_size(rel);
 
    relation_close(rel, AccessShareLock);
 
    PG_RETURN_INT64(size);
}

References AccessShareLock, calculate_total_relation_size(), PG_GETARG_OID, PG_RETURN_INT64, PG_RETURN_NULL, relation_close(), and try_relation_open().

Variable Documentation

size_bytes_aliases

const struct size_bytes_unit_alias size_bytes_aliases[]

static

Initial value:

= {
    {"B", 0},
    {NULL}
}

Definition at line 67 of file dbsize.c.

Referenced by pg_size_bytes().

size_pretty_units

const struct size_pretty_unit size_pretty_units[]

static

Initial value:

= {
    {"bytes", 10 * 1024, false, 0},
    {"kB", 20 * 1024 - 1, true, 10},
    {"MB", 20 * 1024 - 1, true, 20},
    {"GB", 20 * 1024 - 1, true, 30},
    {"TB", 20 * 1024 - 1, true, 40},
    {"PB", 20 * 1024 - 1, true, 50},
    {NULL, 0, false, 0}
}

Definition at line 49 of file dbsize.c.

Referenced by pg_size_bytes(), pg_size_pretty(), and pg_size_pretty_numeric().