tablespace.h File Reference

#include "access/xlogreader.h"
#include "catalog/objectaddress.h"
#include "lib/stringinfo.h"
#include "nodes/parsenodes.h"

Include dependency graph for tablespace.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	xl_tblspc_create_rec
struct	xl_tblspc_drop_rec
struct	TableSpaceOpts

Macros
#define	XLOG_TBLSPC_CREATE   0x00
#define	XLOG_TBLSPC_DROP   0x10

Typedefs
typedef struct xl_tblspc_create_rec	xl_tblspc_create_rec
typedef struct xl_tblspc_drop_rec	xl_tblspc_drop_rec
typedef struct TableSpaceOpts	TableSpaceOpts

Functions
Oid	CreateTableSpace (CreateTableSpaceStmt *stmt)
void	DropTableSpace (DropTableSpaceStmt *stmt)
ObjectAddress	RenameTableSpace (const char *oldname, const char *newname)
Oid	AlterTableSpaceOptions (AlterTableSpaceOptionsStmt *stmt)
void	TablespaceCreateDbspace (Oid spcOid, Oid dbOid, bool isRedo)
Oid	GetDefaultTablespace (char relpersistence, bool partitioned)
void	PrepareTempTablespaces (void)
Oid	get_tablespace_oid (const char *tablespacename, bool missing_ok)
char *	get_tablespace_name (Oid spc_oid)
bool	directory_is_empty (const char *path)
void	remove_tablespace_symlink (const char *linkloc)
void	tblspc_redo (XLogReaderState *record)
void	tblspc_desc (StringInfo buf, XLogReaderState *record)
const char *	tblspc_identify (uint8 info)

Variables
PGDLLIMPORT bool	allow_in_place_tablespaces

Macro Definition Documentation

XLOG_TBLSPC_CREATE

#define XLOG_TBLSPC_CREATE   0x00

Definition at line 25 of file tablespace.h.

XLOG_TBLSPC_DROP

#define XLOG_TBLSPC_DROP   0x10

Definition at line 26 of file tablespace.h.

Typedef Documentation

TableSpaceOpts

typedef struct TableSpaceOpts TableSpaceOpts

xl_tblspc_create_rec

typedef struct xl_tblspc_create_rec xl_tblspc_create_rec

xl_tblspc_drop_rec

typedef struct xl_tblspc_drop_rec xl_tblspc_drop_rec

Function Documentation

AlterTableSpaceOptions()

Oid AlterTableSpaceOptions

(

AlterTableSpaceOptionsStmt *

stmt

)

Definition at line 1021 of file tablespace.c.

{
    Relation    rel;
    ScanKeyData entry[1];
    TableScanDesc scandesc;
    HeapTuple   tup;
    Oid         tablespaceoid;
    Datum       datum;
    Datum       newOptions;
    Datum       repl_val[Natts_pg_tablespace];
    bool        isnull;
    bool        repl_null[Natts_pg_tablespace];
    bool        repl_repl[Natts_pg_tablespace];
    HeapTuple   newtuple;
 
    /* Search pg_tablespace */
    rel = table_open(TableSpaceRelationId, RowExclusiveLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_tablespace_spcname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(stmt->tablespacename));
    scandesc = table_beginscan_catalog(rel, 1, entry);
    tup = heap_getnext(scandesc, ForwardScanDirection);
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("tablespace \"%s\" does not exist",
                        stmt->tablespacename)));
 
    tablespaceoid = ((Form_pg_tablespace) GETSTRUCT(tup))->oid;
 
    /* Must be owner of the existing object */
    if (!object_ownercheck(TableSpaceRelationId, tablespaceoid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TABLESPACE,
                       stmt->tablespacename);
 
    /* Generate new proposed spcoptions (text array) */
    datum = heap_getattr(tup, Anum_pg_tablespace_spcoptions,
                         RelationGetDescr(rel), &isnull);
    newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
                                     stmt->options, NULL, NULL, false,
                                     stmt->isReset);
    (void) tablespace_reloptions(newOptions, true);
 
    /* Build new tuple. */
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
    if (newOptions != (Datum) 0)
        repl_val[Anum_pg_tablespace_spcoptions - 1] = newOptions;
    else
        repl_null[Anum_pg_tablespace_spcoptions - 1] = true;
    repl_repl[Anum_pg_tablespace_spcoptions - 1] = true;
    newtuple = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val,
                                 repl_null, repl_repl);
 
    /* Update system catalog. */
    CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 
    InvokeObjectPostAlterHook(TableSpaceRelationId, tablespaceoid, 0);
 
    heap_freetuple(newtuple);
 
    /* Conclude heap scan. */
    table_endscan(scandesc);
    table_close(rel, NoLock);
 
    return tablespaceoid;
}

References aclcheck_error(), ACLCHECK_NOT_OWNER, BTEqualStrategyNumber, CatalogTupleUpdate(), CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, ForwardScanDirection, GETSTRUCT, GetUserId(), heap_freetuple(), heap_getattr(), heap_getnext(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, NoLock, object_ownercheck(), OBJECT_TABLESPACE, RelationGetDescr, RowExclusiveLock, ScanKeyInit(), stmt, HeapTupleData::t_self, table_beginscan_catalog(), table_close(), table_endscan(), table_open(), tablespace_reloptions(), and transformRelOptions().

Referenced by standard_ProcessUtility().

CreateTableSpace()

Oid CreateTableSpace

(

CreateTableSpaceStmt *

stmt

)

Definition at line 214 of file tablespace.c.

{
    Relation    rel;
    Datum       values[Natts_pg_tablespace];
    bool        nulls[Natts_pg_tablespace] = {0};
    HeapTuple   tuple;
    Oid         tablespaceoid;
    char       *location;
    Oid         ownerId;
    Datum       newOptions;
    bool        in_place;
 
    /* Must be superuser */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create tablespace \"%s\"",
                        stmt->tablespacename),
                 errhint("Must be superuser to create a tablespace.")));
 
    /* However, the eventual owner of the tablespace need not be */
    if (stmt->owner)
        ownerId = get_rolespec_oid(stmt->owner, false);
    else
        ownerId = GetUserId();
 
    /* Unix-ify the offered path, and strip any trailing slashes */
    location = pstrdup(stmt->location);
    canonicalize_path(location);
 
    /* disallow quotes, else CREATE DATABASE would be at risk */
    if (strchr(location, '\''))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tablespace location cannot contain single quotes")));
 
    in_place = allow_in_place_tablespaces && strlen(location) == 0;
 
    /*
     * Allowing relative paths seems risky
     *
     * This also helps us ensure that location is not empty or whitespace,
     * unless specifying a developer-only in-place tablespace.
     */
    if (!in_place && !is_absolute_path(location))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("tablespace location must be an absolute path")));
 
    /*
     * Check that location isn't too long. Remember that we're going to append
     * 'PG_XXX/<dboid>/<relid>_<fork>.<nnn>'.  FYI, we never actually
     * reference the whole path here, but MakePGDirectory() uses the first two
     * parts.
     */
    if (strlen(location) + 1 + strlen(TABLESPACE_VERSION_DIRECTORY) + 1 +
        OIDCHARS + 1 + OIDCHARS + 1 + FORKNAMECHARS + 1 + OIDCHARS > MAXPGPATH)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("tablespace location \"%s\" is too long",
                        location)));
 
    /* Warn if the tablespace is in the data directory. */
    if (path_is_prefix_of_path(DataDir, location))
        ereport(WARNING,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("tablespace location should not be inside the data directory")));
 
    /*
     * Disallow creation of tablespaces named "pg_xxx"; we reserve this
     * namespace for system purposes.
     */
    if (!allowSystemTableMods && IsReservedName(stmt->tablespacename))
        ereport(ERROR,
                (errcode(ERRCODE_RESERVED_NAME),
                 errmsg("unacceptable tablespace name \"%s\"",
                        stmt->tablespacename),
                 errdetail("The prefix \"pg_\" is reserved for system tablespaces.")));
 
    /*
     * If built with appropriate switch, whine when regression-testing
     * conventions for tablespace names are violated.
     */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
    if (strncmp(stmt->tablespacename, "regress_", 8) != 0)
        elog(WARNING, "tablespaces created by regression test cases should have names starting with \"regress_\"");
#endif
 
    /*
     * Check that there is no other tablespace by this name.  (The unique
     * index would catch this anyway, but might as well give a friendlier
     * message.)
     */
    if (OidIsValid(get_tablespace_oid(stmt->tablespacename, true)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("tablespace \"%s\" already exists",
                        stmt->tablespacename)));
 
    /*
     * Insert tuple into pg_tablespace.  The purpose of doing this first is to
     * lock the proposed tablename against other would-be creators. The
     * insertion will roll back if we find problems below.
     */
    rel = table_open(TableSpaceRelationId, RowExclusiveLock);
 
    if (IsBinaryUpgrade)
    {
        /* Use binary-upgrade override for tablespace oid */
        if (!OidIsValid(binary_upgrade_next_pg_tablespace_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("pg_tablespace OID value not set when in binary upgrade mode")));
 
        tablespaceoid = binary_upgrade_next_pg_tablespace_oid;
        binary_upgrade_next_pg_tablespace_oid = InvalidOid;
    }
    else
        tablespaceoid = GetNewOidWithIndex(rel, TablespaceOidIndexId,
                                           Anum_pg_tablespace_oid);
    values[Anum_pg_tablespace_oid - 1] = ObjectIdGetDatum(tablespaceoid);
    values[Anum_pg_tablespace_spcname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(stmt->tablespacename));
    values[Anum_pg_tablespace_spcowner - 1] =
        ObjectIdGetDatum(ownerId);
    nulls[Anum_pg_tablespace_spcacl - 1] = true;
 
    /* Generate new proposed spcoptions (text array) */
    newOptions = transformRelOptions((Datum) 0,
                                     stmt->options,
                                     NULL, NULL, false, false);
    (void) tablespace_reloptions(newOptions, true);
    if (newOptions != (Datum) 0)
        values[Anum_pg_tablespace_spcoptions - 1] = newOptions;
    else
        nulls[Anum_pg_tablespace_spcoptions - 1] = true;
 
    tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
    CatalogTupleInsert(rel, tuple);
 
    heap_freetuple(tuple);
 
    /* Record dependency on owner */
    recordDependencyOnOwner(TableSpaceRelationId, tablespaceoid, ownerId);
 
    /* Post creation hook for new tablespace */
    InvokeObjectPostCreateHook(TableSpaceRelationId, tablespaceoid, 0);
 
    create_tablespace_directories(location, tablespaceoid);
 
    /* Record the filesystem change in XLOG */
    {
        xl_tblspc_create_rec xlrec;
 
        xlrec.ts_id = tablespaceoid;
 
        XLogBeginInsert();
        XLogRegisterData((char *) &xlrec,
                         offsetof(xl_tblspc_create_rec, ts_path));
        XLogRegisterData((char *) location, strlen(location) + 1);
 
        (void) XLogInsert(RM_TBLSPC_ID, XLOG_TBLSPC_CREATE);
    }
 
    /*
     * Force synchronous commit, to minimize the window between creating the
     * symlink on-disk and marking the transaction committed.  It's not great
     * that there is any window at all, but definitely we don't want to make
     * it larger than necessary.
     */
    ForceSyncCommit();
 
    pfree(location);
 
    /* We keep the lock on pg_tablespace until commit */
    table_close(rel, NoLock);
 
    return tablespaceoid;
}

References allow_in_place_tablespaces, allowSystemTableMods, binary_upgrade_next_pg_tablespace_oid, canonicalize_path(), CatalogTupleInsert(), create_tablespace_directories(), CStringGetDatum(), DataDir, DirectFunctionCall1, elog(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errhint(), errmsg(), ERROR, ForceSyncCommit(), FORKNAMECHARS, get_rolespec_oid(), get_tablespace_oid(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), InvalidOid, InvokeObjectPostCreateHook, is_absolute_path, IsBinaryUpgrade, IsReservedName(), MAXPGPATH, namein(), NoLock, ObjectIdGetDatum(), OIDCHARS, OidIsValid, path_is_prefix_of_path(), pfree(), pstrdup(), RelationData::rd_att, recordDependencyOnOwner(), RowExclusiveLock, stmt, superuser(), table_close(), table_open(), tablespace_reloptions(), TABLESPACE_VERSION_DIRECTORY, transformRelOptions(), xl_tblspc_create_rec::ts_id, values, WARNING, XLOG_TBLSPC_CREATE, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by standard_ProcessUtility().

directory_is_empty()

bool directory_is_empty

(

const char *

path

)

Definition at line 859 of file tablespace.c.

{
    DIR        *dirdesc;
    struct dirent *de;
 
    dirdesc = AllocateDir(path);
 
    while ((de = ReadDir(dirdesc, path)) != NULL)
    {
        if (strcmp(de->d_name, ".") == 0 ||
            strcmp(de->d_name, "..") == 0)
            continue;
        FreeDir(dirdesc);
        return false;
    }
 
    FreeDir(dirdesc);
    return true;
}

References AllocateDir(), dirent::d_name, FreeDir(), and ReadDir().

Referenced by CreateDatabaseUsingFileCopy(), createdb(), destroy_tablespace_directories(), and pg_tablespace_databases().

DropTableSpace()

void DropTableSpace

(

DropTableSpaceStmt *

stmt

)

Definition at line 401 of file tablespace.c.

{
    char       *tablespacename = stmt->tablespacename;
    TableScanDesc scandesc;
    Relation    rel;
    HeapTuple   tuple;
    Form_pg_tablespace spcform;
    ScanKeyData entry[1];
    Oid         tablespaceoid;
    char       *detail;
    char       *detail_log;
 
    /*
     * Find the target tuple
     */
    rel = table_open(TableSpaceRelationId, RowExclusiveLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_tablespace_spcname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(tablespacename));
    scandesc = table_beginscan_catalog(rel, 1, entry);
    tuple = heap_getnext(scandesc, ForwardScanDirection);
 
    if (!HeapTupleIsValid(tuple))
    {
        if (!stmt->missing_ok)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("tablespace \"%s\" does not exist",
                            tablespacename)));
        }
        else
        {
            ereport(NOTICE,
                    (errmsg("tablespace \"%s\" does not exist, skipping",
                            tablespacename)));
            table_endscan(scandesc);
            table_close(rel, NoLock);
        }
        return;
    }
 
    spcform = (Form_pg_tablespace) GETSTRUCT(tuple);
    tablespaceoid = spcform->oid;
 
    /* Must be tablespace owner */
    if (!object_ownercheck(TableSpaceRelationId, tablespaceoid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TABLESPACE,
                       tablespacename);
 
    /* Disallow drop of the standard tablespaces, even by superuser */
    if (IsPinnedObject(TableSpaceRelationId, tablespaceoid))
        aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_TABLESPACE,
                       tablespacename);
 
    /* Check for pg_shdepend entries depending on this tablespace */
    if (checkSharedDependencies(TableSpaceRelationId, tablespaceoid,
                                &detail, &detail_log))
        ereport(ERROR,
                (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
                 errmsg("tablespace \"%s\" cannot be dropped because some objects depend on it",
                        tablespacename),
                 errdetail_internal("%s", detail),
                 errdetail_log("%s", detail_log)));
 
    /* DROP hook for the tablespace being removed */
    InvokeObjectDropHook(TableSpaceRelationId, tablespaceoid, 0);
 
    /*
     * Remove the pg_tablespace tuple (this will roll back if we fail below)
     */
    CatalogTupleDelete(rel, &tuple->t_self);
 
    table_endscan(scandesc);
 
    /*
     * Remove any comments or security labels on this tablespace.
     */
    DeleteSharedComments(tablespaceoid, TableSpaceRelationId);
    DeleteSharedSecurityLabel(tablespaceoid, TableSpaceRelationId);
 
    /*
     * Remove dependency on owner.
     */
    deleteSharedDependencyRecordsFor(TableSpaceRelationId, tablespaceoid, 0);
 
    /*
     * Acquire TablespaceCreateLock to ensure that no TablespaceCreateDbspace
     * is running concurrently.
     */
    LWLockAcquire(TablespaceCreateLock, LW_EXCLUSIVE);
 
    /*
     * Try to remove the physical infrastructure.
     */
    if (!destroy_tablespace_directories(tablespaceoid, false))
    {
        /*
         * Not all files deleted?  However, there can be lingering empty files
         * in the directories, left behind by for example DROP TABLE, that
         * have been scheduled for deletion at next checkpoint (see comments
         * in mdunlink() for details).  We could just delete them immediately,
         * but we can't tell them apart from important data files that we
         * mustn't delete.  So instead, we force a checkpoint which will clean
         * out any lingering files, and try again.
         */
        RequestCheckpoint(CHECKPOINT_IMMEDIATE | CHECKPOINT_FORCE | CHECKPOINT_WAIT);
 
        /*
         * On Windows, an unlinked file persists in the directory listing
         * until no process retains an open handle for the file.  The DDL
         * commands that schedule files for unlink send invalidation messages
         * directing other PostgreSQL processes to close the files, but
         * nothing guarantees they'll be processed in time.  So, we'll also
         * use a global barrier to ask all backends to close all files, and
         * wait until they're finished.
         */
        LWLockRelease(TablespaceCreateLock);
        WaitForProcSignalBarrier(EmitProcSignalBarrier(PROCSIGNAL_BARRIER_SMGRRELEASE));
        LWLockAcquire(TablespaceCreateLock, LW_EXCLUSIVE);
 
        /* And now try again. */
        if (!destroy_tablespace_directories(tablespaceoid, false))
        {
            /* Still not empty, the files must be important then */
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("tablespace \"%s\" is not empty",
                            tablespacename)));
        }
    }
 
    /* Record the filesystem change in XLOG */
    {
        xl_tblspc_drop_rec xlrec;
 
        xlrec.ts_id = tablespaceoid;
 
        XLogBeginInsert();
        XLogRegisterData((char *) &xlrec, sizeof(xl_tblspc_drop_rec));
 
        (void) XLogInsert(RM_TBLSPC_ID, XLOG_TBLSPC_DROP);
    }
 
    /*
     * Note: because we checked that the tablespace was empty, there should be
     * no need to worry about flushing shared buffers or free space map
     * entries for relations in the tablespace.
     */
 
    /*
     * Force synchronous commit, to minimize the window between removing the
     * files on-disk and marking the transaction committed.  It's not great
     * that there is any window at all, but definitely we don't want to make
     * it larger than necessary.
     */
    ForceSyncCommit();
 
    /*
     * Allow TablespaceCreateDbspace again.
     */
    LWLockRelease(TablespaceCreateLock);
 
    /* We keep the lock on pg_tablespace until commit */
    table_close(rel, NoLock);
}

References aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_NOT_OWNER, BTEqualStrategyNumber, CatalogTupleDelete(), CHECKPOINT_FORCE, CHECKPOINT_IMMEDIATE, CHECKPOINT_WAIT, checkSharedDependencies(), CStringGetDatum(), DeleteSharedComments(), deleteSharedDependencyRecordsFor(), DeleteSharedSecurityLabel(), destroy_tablespace_directories(), EmitProcSignalBarrier(), ereport, errcode(), errdetail_internal(), errdetail_log(), errmsg(), ERROR, ForceSyncCommit(), ForwardScanDirection, GETSTRUCT, GetUserId(), heap_getnext(), HeapTupleIsValid, InvokeObjectDropHook, IsPinnedObject(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), NoLock, NOTICE, object_ownercheck(), OBJECT_TABLESPACE, PROCSIGNAL_BARRIER_SMGRRELEASE, RequestCheckpoint(), RowExclusiveLock, ScanKeyInit(), stmt, HeapTupleData::t_self, table_beginscan_catalog(), table_close(), table_endscan(), table_open(), xl_tblspc_drop_rec::ts_id, WaitForProcSignalBarrier(), XLOG_TBLSPC_DROP, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by standard_ProcessUtility().

get_tablespace_name()

char* get_tablespace_name

(

Oid

spc_oid

)

Definition at line 1478 of file tablespace.c.

{
    char       *result;
    Relation    rel;
    TableScanDesc scandesc;
    HeapTuple   tuple;
    ScanKeyData entry[1];
 
    /*
     * Search pg_tablespace.  We use a heapscan here even though there is an
     * index on oid, on the theory that pg_tablespace will usually have just a
     * few entries and so an indexed lookup is a waste of effort.
     */
    rel = table_open(TableSpaceRelationId, AccessShareLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_tablespace_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(spc_oid));
    scandesc = table_beginscan_catalog(rel, 1, entry);
    tuple = heap_getnext(scandesc, ForwardScanDirection);
 
    /* We assume that there can be at most one matching tuple */
    if (HeapTupleIsValid(tuple))
        result = pstrdup(NameStr(((Form_pg_tablespace) GETSTRUCT(tuple))->spcname));
    else
        result = NULL;
 
    table_endscan(scandesc);
    table_close(rel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, ForwardScanDirection, GETSTRUCT, heap_getnext(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), pstrdup(), ScanKeyInit(), table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by AlterTableMoveAll(), calculate_tablespace_size(), DefineIndex(), DefineRelation(), ExecReindex(), generateClonedIndexStmt(), getObjectDescription(), getObjectIdentityParts(), pg_get_constraintdef_worker(), pg_get_indexdef_worker(), ReindexMultipleInternal(), ReindexRelationConcurrently(), and shdepLockAndCheckObject().

get_tablespace_oid()

Oid get_tablespace_oid	(	const char *	tablespacename,
		bool	missing_ok
	)

Definition at line 1432 of file tablespace.c.

{
    Oid         result;
    Relation    rel;
    TableScanDesc scandesc;
    HeapTuple   tuple;
    ScanKeyData entry[1];
 
    /*
     * Search pg_tablespace.  We use a heapscan here even though there is an
     * index on name, on the theory that pg_tablespace will usually have just
     * a few entries and so an indexed lookup is a waste of effort.
     */
    rel = table_open(TableSpaceRelationId, AccessShareLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_tablespace_spcname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(tablespacename));
    scandesc = table_beginscan_catalog(rel, 1, entry);
    tuple = heap_getnext(scandesc, ForwardScanDirection);
 
    /* We assume that there can be at most one matching tuple */
    if (HeapTupleIsValid(tuple))
        result = ((Form_pg_tablespace) GETSTRUCT(tuple))->oid;
    else
        result = InvalidOid;
 
    table_endscan(scandesc);
    table_close(rel, AccessShareLock);
 
    if (!OidIsValid(result) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("tablespace \"%s\" does not exist",
                        tablespacename)));
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, ForwardScanDirection, GETSTRUCT, heap_getnext(), HeapTupleIsValid, InvalidOid, OidIsValid, ScanKeyInit(), table_beginscan_catalog(), table_close(), table_endscan(), and table_open().

Referenced by AlterTableMoveAll(), ATPrepSetTableSpace(), check_default_tablespace(), check_temp_tablespaces(), convert_tablespace_name(), createdb(), CreateTableSpace(), DefineIndex(), DefineRelation(), ExecReindex(), get_object_address_unqualified(), GetDefaultTablespace(), movedb(), objectNamesToOids(), pg_tablespace_size_name(), and PrepareTempTablespaces().

GetDefaultTablespace()

Oid GetDefaultTablespace	(	char	relpersistence,
		bool	partitioned
	)

Definition at line 1149 of file tablespace.c.

{
    Oid         result;
 
    /* The temp-table case is handled elsewhere */
    if (relpersistence == RELPERSISTENCE_TEMP)
    {
        PrepareTempTablespaces();
        return GetNextTempTableSpace();
    }
 
    /* Fast path for default_tablespace == "" */
    if (default_tablespace == NULL || default_tablespace[0] == '\0')
        return InvalidOid;
 
    /*
     * It is tempting to cache this lookup for more speed, but then we would
     * fail to detect the case where the tablespace was dropped since the GUC
     * variable was set.  Note also that we don't complain if the value fails
     * to refer to an existing tablespace; we just silently return InvalidOid,
     * causing the new object to be created in the database's tablespace.
     */
    result = get_tablespace_oid(default_tablespace, true);
 
    /*
     * Allow explicit specification of database's default tablespace in
     * default_tablespace without triggering permissions checks.  Don't allow
     * specifying that when creating a partitioned table, however, since the
     * result is confusing.
     */
    if (result == MyDatabaseTableSpace)
    {
        if (partitioned)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot specify default tablespace for partitioned relations")));
        result = InvalidOid;
    }
    return result;
}

References default_tablespace, ereport, errcode(), errmsg(), ERROR, get_tablespace_oid(), GetNextTempTableSpace(), InvalidOid, MyDatabaseTableSpace, and PrepareTempTablespaces().

Referenced by DefineIndex(), DefineRelation(), and ExecRefreshMatView().

PrepareTempTablespaces()

void PrepareTempTablespaces

(

void

)

Definition at line 1337 of file tablespace.c.

{
    char       *rawname;
    List       *namelist;
    Oid        *tblSpcs;
    int         numSpcs;
    ListCell   *l;
 
    /* No work if already done in current transaction */
    if (TempTablespacesAreSet())
        return;
 
    /*
     * Can't do catalog access unless within a transaction.  This is just a
     * safety check in case this function is called by low-level code that
     * could conceivably execute outside a transaction.  Note that in such a
     * scenario, fd.c will fall back to using the current database's default
     * tablespace, which should always be OK.
     */
    if (!IsTransactionState())
        return;
 
    /* Need a modifiable copy of string */
    rawname = pstrdup(temp_tablespaces);
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawname, ',', &namelist))
    {
        /* syntax error in name list */
        SetTempTablespaces(NULL, 0);
        pfree(rawname);
        list_free(namelist);
        return;
    }
 
    /* Store tablespace OIDs in an array in TopTransactionContext */
    tblSpcs = (Oid *) MemoryContextAlloc(TopTransactionContext,
                                         list_length(namelist) * sizeof(Oid));
    numSpcs = 0;
    foreach(l, namelist)
    {
        char       *curname = (char *) lfirst(l);
        Oid         curoid;
        AclResult   aclresult;
 
        /* Allow an empty string (signifying database default) */
        if (curname[0] == '\0')
        {
            /* InvalidOid signifies database's default tablespace */
            tblSpcs[numSpcs++] = InvalidOid;
            continue;
        }
 
        /* Else verify that name is a valid tablespace name */
        curoid = get_tablespace_oid(curname, true);
        if (curoid == InvalidOid)
        {
            /* Skip any bad list elements */
            continue;
        }
 
        /*
         * Allow explicit specification of database's default tablespace in
         * temp_tablespaces without triggering permissions checks.
         */
        if (curoid == MyDatabaseTableSpace)
        {
            /* InvalidOid signifies database's default tablespace */
            tblSpcs[numSpcs++] = InvalidOid;
            continue;
        }
 
        /* Check permissions similarly */
        aclresult = object_aclcheck(TableSpaceRelationId, curoid, GetUserId(),
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            continue;
 
        tblSpcs[numSpcs++] = curoid;
    }
 
    SetTempTablespaces(tblSpcs, numSpcs);
 
    pfree(rawname);
    list_free(namelist);
}

References ACL_CREATE, ACLCHECK_OK, get_tablespace_oid(), GetUserId(), InvalidOid, IsTransactionState(), lfirst, list_free(), list_length(), MemoryContextAlloc(), MyDatabaseTableSpace, object_aclcheck(), pfree(), pstrdup(), SetTempTablespaces(), SplitIdentifierString(), temp_tablespaces, TempTablespacesAreSet(), and TopTransactionContext.

Referenced by BufFileCreateTemp(), ExecHashIncreaseNumBatches(), ExecHashTableCreate(), FileSetInit(), GetDefaultTablespace(), inittapestate(), and tuplestore_puttuple_common().

remove_tablespace_symlink()

void remove_tablespace_symlink

(

const char *

linkloc

)

Definition at line 889 of file tablespace.c.

{
    struct stat st;
 
    if (lstat(linkloc, &st) < 0)
    {
        if (errno == ENOENT)
            return;
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not stat file \"%s\": %m", linkloc)));
    }
 
    if (S_ISDIR(st.st_mode))
    {
        /*
         * This will fail if the directory isn't empty, but not if it's a
         * junction point.
         */
        if (rmdir(linkloc) < 0 && errno != ENOENT)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not remove directory \"%s\": %m",
                            linkloc)));
    }
    else if (S_ISLNK(st.st_mode))
    {
        if (unlink(linkloc) < 0 && errno != ENOENT)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not remove symbolic link \"%s\": %m",
                            linkloc)));
    }
    else
    {
        /* Refuse to remove anything that's not a directory or symlink */
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("\"%s\" is not a directory or symbolic link",
                        linkloc)));
    }
}

References ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, lstat, S_ISDIR, S_ISLNK, and stat::st_mode.

Referenced by create_tablespace_directories(), and InitWalRecovery().

RenameTableSpace()

ObjectAddress RenameTableSpace	(	const char *	oldname,
		const char *	newname
	)

Definition at line 936 of file tablespace.c.

{
    Oid         tspId;
    Relation    rel;
    ScanKeyData entry[1];
    TableScanDesc scan;
    HeapTuple   tup;
    HeapTuple   newtuple;
    Form_pg_tablespace newform;
    ObjectAddress address;
 
    /* Search pg_tablespace */
    rel = table_open(TableSpaceRelationId, RowExclusiveLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_tablespace_spcname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(oldname));
    scan = table_beginscan_catalog(rel, 1, entry);
    tup = heap_getnext(scan, ForwardScanDirection);
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("tablespace \"%s\" does not exist",
                        oldname)));
 
    newtuple = heap_copytuple(tup);
    newform = (Form_pg_tablespace) GETSTRUCT(newtuple);
    tspId = newform->oid;
 
    table_endscan(scan);
 
    /* Must be owner */
    if (!object_ownercheck(TableSpaceRelationId, tspId, GetUserId()))
        aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_TABLESPACE, oldname);
 
    /* Validate new name */
    if (!allowSystemTableMods && IsReservedName(newname))
        ereport(ERROR,
                (errcode(ERRCODE_RESERVED_NAME),
                 errmsg("unacceptable tablespace name \"%s\"", newname),
                 errdetail("The prefix \"pg_\" is reserved for system tablespaces.")));
 
    /*
     * If built with appropriate switch, whine when regression-testing
     * conventions for tablespace names are violated.
     */
#ifdef ENFORCE_REGRESSION_TEST_NAME_RESTRICTIONS
    if (strncmp(newname, "regress_", 8) != 0)
        elog(WARNING, "tablespaces created by regression test cases should have names starting with \"regress_\"");
#endif
 
    /* Make sure the new name doesn't exist */
    ScanKeyInit(&entry[0],
                Anum_pg_tablespace_spcname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(newname));
    scan = table_beginscan_catalog(rel, 1, entry);
    tup = heap_getnext(scan, ForwardScanDirection);
    if (HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("tablespace \"%s\" already exists",
                        newname)));
 
    table_endscan(scan);
 
    /* OK, update the entry */
    namestrcpy(&(newform->spcname), newname);
 
    CatalogTupleUpdate(rel, &newtuple->t_self, newtuple);
 
    InvokeObjectPostAlterHook(TableSpaceRelationId, tspId, 0);
 
    ObjectAddressSet(address, TableSpaceRelationId, tspId);
 
    table_close(rel, NoLock);
 
    return address;
}

References aclcheck_error(), ACLCHECK_NO_PRIV, allowSystemTableMods, BTEqualStrategyNumber, CatalogTupleUpdate(), CStringGetDatum(), elog(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail(), errmsg(), ERROR, ForwardScanDirection, GETSTRUCT, GetUserId(), heap_copytuple(), heap_getnext(), HeapTupleIsValid, InvokeObjectPostAlterHook, IsReservedName(), namestrcpy(), NoLock, object_ownercheck(), OBJECT_TABLESPACE, ObjectAddressSet, RowExclusiveLock, ScanKeyInit(), HeapTupleData::t_self, table_beginscan_catalog(), table_close(), table_endscan(), table_open(), and WARNING.

Referenced by ExecRenameStmt().

TablespaceCreateDbspace()

void TablespaceCreateDbspace	(	Oid	spcOid,
		Oid	dbOid,
		bool	isRedo
	)

Definition at line 118 of file tablespace.c.

{
    struct stat st;
    char       *dir;
 
    /*
     * The global tablespace doesn't have per-database subdirectories, so
     * nothing to do for it.
     */
    if (spcOid == GLOBALTABLESPACE_OID)
        return;
 
    Assert(OidIsValid(spcOid));
    Assert(OidIsValid(dbOid));
 
    dir = GetDatabasePath(dbOid, spcOid);
 
    if (stat(dir, &st) < 0)
    {
        /* Directory does not exist? */
        if (errno == ENOENT)
        {
            /*
             * Acquire TablespaceCreateLock to ensure that no DROP TABLESPACE
             * or TablespaceCreateDbspace is running concurrently.
             */
            LWLockAcquire(TablespaceCreateLock, LW_EXCLUSIVE);
 
            /*
             * Recheck to see if someone created the directory while we were
             * waiting for lock.
             */
            if (stat(dir, &st) == 0 && S_ISDIR(st.st_mode))
            {
                /* Directory was created */
            }
            else
            {
                /* Directory creation failed? */
                if (MakePGDirectory(dir) < 0)
                {
                    /* Failure other than not exists or not in WAL replay? */
                    if (errno != ENOENT || !isRedo)
                        ereport(ERROR,
                                (errcode_for_file_access(),
                                 errmsg("could not create directory \"%s\": %m",
                                        dir)));
 
                    /*
                     * During WAL replay, it's conceivable that several levels
                     * of directories are missing if tablespaces are dropped
                     * further ahead of the WAL stream than we're currently
                     * replaying.  An easy way forward is to create them as
                     * plain directories and hope they are removed by further
                     * WAL replay if necessary.  If this also fails, there is
                     * trouble we cannot get out of, so just report that and
                     * bail out.
                     */
                    if (pg_mkdir_p(dir, pg_dir_create_mode) < 0)
                        ereport(ERROR,
                                (errcode_for_file_access(),
                                 errmsg("could not create directory \"%s\": %m",
                                        dir)));
                }
            }
 
            LWLockRelease(TablespaceCreateLock);
        }
        else
        {
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not stat directory \"%s\": %m", dir)));
        }
    }
    else
    {
        /* Is it not a directory? */
        if (!S_ISDIR(st.st_mode))
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("\"%s\" exists but is not a directory",
                            dir)));
    }
 
    pfree(dir);
}

References Assert(), ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, GetDatabasePath(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MakePGDirectory(), OidIsValid, pfree(), pg_dir_create_mode, pg_mkdir_p(), S_ISDIR, stat::st_mode, and stat.

Referenced by mdcreate().

tblspc_desc()

void tblspc_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 21 of file tblspcdesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    if (info == XLOG_TBLSPC_CREATE)
    {
        xl_tblspc_create_rec *xlrec = (xl_tblspc_create_rec *) rec;
 
        appendStringInfo(buf, "%u \"%s\"", xlrec->ts_id, xlrec->ts_path);
    }
    else if (info == XLOG_TBLSPC_DROP)
    {
        xl_tblspc_drop_rec *xlrec = (xl_tblspc_drop_rec *) rec;
 
        appendStringInfo(buf, "%u", xlrec->ts_id);
    }
}

References appendStringInfo(), buf, xl_tblspc_create_rec::ts_id, xl_tblspc_drop_rec::ts_id, xl_tblspc_create_rec::ts_path, XLOG_TBLSPC_CREATE, XLOG_TBLSPC_DROP, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

tblspc_identify()

const char* tblspc_identify

(

uint8

info

)

Definition at line 41 of file tblspcdesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_TBLSPC_CREATE:
            id = "CREATE";
            break;
        case XLOG_TBLSPC_DROP:
            id = "DROP";
            break;
    }
 
    return id;
}

References XLOG_TBLSPC_CREATE, XLOG_TBLSPC_DROP, and XLR_INFO_MASK.

tblspc_redo()

void tblspc_redo

(

XLogReaderState *

record

)

Definition at line 1517 of file tablespace.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    /* Backup blocks are not used in tblspc records */
    Assert(!XLogRecHasAnyBlockRefs(record));
 
    if (info == XLOG_TBLSPC_CREATE)
    {
        xl_tblspc_create_rec *xlrec = (xl_tblspc_create_rec *) XLogRecGetData(record);
        char       *location = xlrec->ts_path;
 
        create_tablespace_directories(location, xlrec->ts_id);
    }
    else if (info == XLOG_TBLSPC_DROP)
    {
        xl_tblspc_drop_rec *xlrec = (xl_tblspc_drop_rec *) XLogRecGetData(record);
 
        /* Close all smgr fds in all backends. */
        WaitForProcSignalBarrier(EmitProcSignalBarrier(PROCSIGNAL_BARRIER_SMGRRELEASE));
 
        /*
         * If we issued a WAL record for a drop tablespace it implies that
         * there were no files in it at all when the DROP was done. That means
         * that no permanent objects can exist in it at this point.
         *
         * It is possible for standby users to be using this tablespace as a
         * location for their temporary files, so if we fail to remove all
         * files then do conflict processing and try again, if currently
         * enabled.
         *
         * Other possible reasons for failure include bollixed file
         * permissions on a standby server when they were okay on the primary,
         * etc etc. There's not much we can do about that, so just remove what
         * we can and press on.
         */
        if (!destroy_tablespace_directories(xlrec->ts_id, true))
        {
            ResolveRecoveryConflictWithTablespace(xlrec->ts_id);
 
            /*
             * If we did recovery processing then hopefully the backends who
             * wrote temp files should have cleaned up and exited by now.  So
             * retry before complaining.  If we fail again, this is just a LOG
             * condition, because it's not worth throwing an ERROR for (as
             * that would crash the database and require manual intervention
             * before we could get past this WAL record on restart).
             */
            if (!destroy_tablespace_directories(xlrec->ts_id, true))
                ereport(LOG,
                        (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                         errmsg("directories for tablespace %u could not be removed",
                                xlrec->ts_id),
                         errhint("You can remove the directories manually if necessary.")));
        }
    }
    else
        elog(PANIC, "tblspc_redo: unknown op code %u", info);
}

References Assert(), create_tablespace_directories(), destroy_tablespace_directories(), elog(), EmitProcSignalBarrier(), ereport, errcode(), errhint(), errmsg(), LOG, PANIC, PROCSIGNAL_BARRIER_SMGRRELEASE, ResolveRecoveryConflictWithTablespace(), xl_tblspc_create_rec::ts_id, xl_tblspc_drop_rec::ts_id, xl_tblspc_create_rec::ts_path, WaitForProcSignalBarrier(), XLOG_TBLSPC_CREATE, XLOG_TBLSPC_DROP, XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, and XLR_INFO_MASK.

Variable Documentation

allow_in_place_tablespaces

PGDLLIMPORT bool allow_in_place_tablespaces

extern

Definition at line 91 of file tablespace.c.

Referenced by CheckTablespaceDirectory(), CreateTableSpace(), and recovery_create_dbdir().