namespace.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/parallel.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/dependency.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "parser/parse_func.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "storage/sinvaladt.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/guc.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/syscache.h"
#include "utils/varlena.h"

Include dependency graph for namespace.c:

Go to the source code of this file.

Data Structures
struct	OverrideStackEntry

Macros
#define	SPACE_PER_OP

Functions
static void	recomputeNamespacePath (void)
static void	AccessTempTableNamespace (bool force)
static void	InitTempTableNamespace (void)
static void	RemoveTempRelations (Oid tempNamespaceId)
static void	RemoveTempRelationsCallback (int code, Datum arg)
static void	NamespaceCallback (Datum arg, int cacheid, uint32 hashvalue)
static bool	MatchNamedCall (HeapTuple proctup, int nargs, List *argnames, int **argnumbers)
Oid	RangeVarGetRelidExtended (const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Oid	RangeVarGetCreationNamespace (const RangeVar *newRelation)
Oid	RangeVarGetAndCheckCreationNamespace (RangeVar *relation, LOCKMODE lockmode, Oid *existing_relation_id)
void	RangeVarAdjustRelationPersistence (RangeVar *newRelation, Oid nspid)
Oid	RelnameGetRelid (const char *relname)
bool	RelationIsVisible (Oid relid)
Oid	TypenameGetTypid (const char *typname)
Oid	TypenameGetTypidExtended (const char *typname, bool temp_ok)
bool	TypeIsVisible (Oid typid)
FuncCandidateList	FuncnameGetCandidates (List *names, int nargs, List *argnames, bool expand_variadic, bool expand_defaults, bool missing_ok)
bool	FunctionIsVisible (Oid funcid)
Oid	OpernameGetOprid (List *names, Oid oprleft, Oid oprright)
FuncCandidateList	OpernameGetCandidates (List *names, char oprkind, bool missing_schema_ok)
bool	OperatorIsVisible (Oid oprid)
Oid	OpclassnameGetOpcid (Oid amid, const char *opcname)
bool	OpclassIsVisible (Oid opcid)
Oid	OpfamilynameGetOpfid (Oid amid, const char *opfname)
bool	OpfamilyIsVisible (Oid opfid)
static Oid	lookup_collation (const char *collname, Oid collnamespace, int32 encoding)
Oid	CollationGetCollid (const char *collname)
bool	CollationIsVisible (Oid collid)
Oid	ConversionGetConid (const char *conname)
bool	ConversionIsVisible (Oid conid)
Oid	get_statistics_object_oid (List *names, bool missing_ok)
bool	StatisticsObjIsVisible (Oid relid)
Oid	get_ts_parser_oid (List *names, bool missing_ok)
bool	TSParserIsVisible (Oid prsId)
Oid	get_ts_dict_oid (List *names, bool missing_ok)
bool	TSDictionaryIsVisible (Oid dictId)
Oid	get_ts_template_oid (List *names, bool missing_ok)
bool	TSTemplateIsVisible (Oid tmplId)
Oid	get_ts_config_oid (List *names, bool missing_ok)
bool	TSConfigIsVisible (Oid cfgid)
void	DeconstructQualifiedName (List *names, char **nspname_p, char **objname_p)
Oid	LookupNamespaceNoError (const char *nspname)
Oid	LookupExplicitNamespace (const char *nspname, bool missing_ok)
Oid	LookupCreationNamespace (const char *nspname)
void	CheckSetNamespace (Oid oldNspOid, Oid nspOid)
Oid	QualifiedNameGetCreationNamespace (List *names, char **objname_p)
Oid	get_namespace_oid (const char *nspname, bool missing_ok)
RangeVar *	makeRangeVarFromNameList (List *names)
char *	NameListToString (List *names)
char *	NameListToQuotedString (List *names)
bool	isTempNamespace (Oid namespaceId)
bool	isTempToastNamespace (Oid namespaceId)
bool	isTempOrTempToastNamespace (Oid namespaceId)
bool	isAnyTempNamespace (Oid namespaceId)
bool	isOtherTempNamespace (Oid namespaceId)
TempNamespaceStatus	checkTempNamespaceStatus (Oid namespaceId)
int	GetTempNamespaceBackendId (Oid namespaceId)
Oid	GetTempToastNamespace (void)
void	GetTempNamespaceState (Oid *tempNamespaceId, Oid *tempToastNamespaceId)
void	SetTempNamespaceState (Oid tempNamespaceId, Oid tempToastNamespaceId)
OverrideSearchPath *	GetOverrideSearchPath (MemoryContext context)
OverrideSearchPath *	CopyOverrideSearchPath (OverrideSearchPath *path)
bool	OverrideSearchPathMatchesCurrent (OverrideSearchPath *path)
void	PushOverrideSearchPath (OverrideSearchPath *newpath)
void	PopOverrideSearchPath (void)
Oid	get_collation_oid (List *name, bool missing_ok)
Oid	get_conversion_oid (List *name, bool missing_ok)
Oid	FindDefaultConversionProc (int32 for_encoding, int32 to_encoding)
void	AtEOXact_Namespace (bool isCommit, bool parallel)
void	AtEOSubXact_Namespace (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
void	ResetTempTableNamespace (void)
bool	check_search_path (char **newval, void **extra, GucSource source)
void	assign_search_path (const char *newval, void *extra)
void	InitializeSearchPath (void)
List *	fetch_search_path (bool includeImplicit)
int	fetch_search_path_array (Oid *sarray, int sarray_len)
Datum	pg_table_is_visible (PG_FUNCTION_ARGS)
Datum	pg_type_is_visible (PG_FUNCTION_ARGS)
Datum	pg_function_is_visible (PG_FUNCTION_ARGS)
Datum	pg_operator_is_visible (PG_FUNCTION_ARGS)
Datum	pg_opclass_is_visible (PG_FUNCTION_ARGS)
Datum	pg_opfamily_is_visible (PG_FUNCTION_ARGS)
Datum	pg_collation_is_visible (PG_FUNCTION_ARGS)
Datum	pg_conversion_is_visible (PG_FUNCTION_ARGS)
Datum	pg_statistics_obj_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_parser_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_dict_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_template_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_config_is_visible (PG_FUNCTION_ARGS)
Datum	pg_my_temp_schema (PG_FUNCTION_ARGS)
Datum	pg_is_other_temp_schema (PG_FUNCTION_ARGS)

Variables
static List *	activeSearchPath = NIL
static Oid	activeCreationNamespace = InvalidOid
static bool	activeTempCreationPending = false
static uint64	activePathGeneration = 1
static List *	baseSearchPath = NIL
static Oid	baseCreationNamespace = InvalidOid
static bool	baseTempCreationPending = false
static Oid	namespaceUser = InvalidOid
static bool	baseSearchPathValid = true
static List *	overrideStack = NIL
static Oid	myTempNamespace = InvalidOid
static Oid	myTempToastNamespace = InvalidOid
static SubTransactionId	myTempNamespaceSubID = InvalidSubTransactionId
char *	namespace_search_path = NULL

Macro Definition Documentation

SPACE_PER_OP

#define SPACE_PER_OP

Value:

MAXALIGN(offsetof(struct _FuncCandidateList, args) + \
                              2 * sizeof(Oid))

Referenced by OpernameGetCandidates().

Function Documentation

AccessTempTableNamespace()

static void AccessTempTableNamespace ( bool  force )

static

Definition at line 3914 of file namespace.c.

References InitTempTableNamespace(), myTempNamespace, MyXactFlags, OidIsValid, and XACT_FLAGS_ACCESSEDTEMPNAMESPACE.

Referenced by fetch_search_path(), LookupCreationNamespace(), QualifiedNameGetCreationNamespace(), and RangeVarGetCreationNamespace().

{
    /*
     * Make note that this temporary namespace has been accessed in this
     * transaction.
     */
    MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;

    /*
     * If the caller attempting to access a temporary schema expects the
     * creation of the namespace to be pending and should be enforced, then go
     * through the creation.
     */
    if (!force && OidIsValid(myTempNamespace))
        return;

    /*
     * The temporary tablespace does not exist yet and is wanted, so
     * initialize it.
     */
    InitTempTableNamespace();
}

assign_search_path()

void assign_search_path	(	const char *	newval,
		void *	extra
	)

Definition at line 4307 of file namespace.c.

References baseSearchPathValid.

{
    /*
     * We mark the path as needing recomputation, but don't do anything until
     * it's needed.  This avoids trying to do database access during GUC
     * initialization, or outside a transaction.
     */
    baseSearchPathValid = false;
}

AtEOSubXact_Namespace()

void AtEOSubXact_Namespace	(	bool	isCommit,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

Definition at line 4131 of file namespace.c.

References activeCreationNamespace, activePathGeneration, activeTempCreationPending, baseCreationNamespace, baseSearchPath, baseSearchPathValid, baseTempCreationPending, OverrideStackEntry::creationNamespace, elog, GetCurrentTransactionNestLevel(), InvalidOid, InvalidSubTransactionId, linitial, list_delete_first(), list_free(), MyProc, myTempNamespace, myTempNamespaceSubID, myTempToastNamespace, OverrideStackEntry::nestLevel, pfree(), OverrideStackEntry::searchPath, PGPROC::tempNamespaceId, and WARNING.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

{
    OverrideStackEntry *entry;

    if (myTempNamespaceSubID == mySubid)
    {
        if (isCommit)
            myTempNamespaceSubID = parentSubid;
        else
        {
            myTempNamespaceSubID = InvalidSubTransactionId;
            /* TEMP namespace creation failed, so reset state */
            myTempNamespace = InvalidOid;
            myTempToastNamespace = InvalidOid;
            baseSearchPathValid = false;    /* need to rebuild list */

            /*
             * Reset the temporary namespace flag in MyProc.  We assume that
             * this operation is atomic.
             *
             * Because this subtransaction is aborting, the pg_namespace row
             * is not visible to anyone else anyway, but that doesn't matter:
             * it's not a problem if objects contained in this namespace are
             * removed concurrently.
             */
            MyProc->tempNamespaceId = InvalidOid;
        }
    }

    /*
     * Clean up if someone failed to do PopOverrideSearchPath
     */
    while (overrideStack)
    {
        entry = (OverrideStackEntry *) linitial(overrideStack);
        if (entry->nestLevel < GetCurrentTransactionNestLevel())
            break;
        if (isCommit)
            elog(WARNING, "leaked override search path");
        overrideStack = list_delete_first(overrideStack);
        list_free(entry->searchPath);
        pfree(entry);
        /* Always bump generation --- see note in recomputeNamespacePath */
        activePathGeneration++;
    }

    /* Activate the next level down. */
    if (overrideStack)
    {
        entry = (OverrideStackEntry *) linitial(overrideStack);
        activeSearchPath = entry->searchPath;
        activeCreationNamespace = entry->creationNamespace;
        activeTempCreationPending = false;  /* XXX is this OK? */

        /*
         * It's probably unnecessary to bump generation here, but this should
         * not be a performance-critical case, so better to be over-cautious.
         */
        activePathGeneration++;
    }
    else
    {
        /* If not baseSearchPathValid, this is useless but harmless */
        activeSearchPath = baseSearchPath;
        activeCreationNamespace = baseCreationNamespace;
        activeTempCreationPending = baseTempCreationPending;

        /*
         * If we popped an override stack entry, then we already bumped the
         * generation above.  If we did not, then the above assignments did
         * nothing and we need not bump the generation.
         */
    }
}

AtEOXact_Namespace()

void AtEOXact_Namespace	(	bool	isCommit,
		bool	parallel
	)

Definition at line 4063 of file namespace.c.

References activeCreationNamespace, activePathGeneration, activeTempCreationPending, baseCreationNamespace, baseSearchPath, baseSearchPathValid, baseTempCreationPending, before_shmem_exit(), elog, InvalidOid, InvalidSubTransactionId, linitial, list_delete_first(), list_free(), MyProc, myTempNamespace, myTempNamespaceSubID, myTempToastNamespace, pfree(), RemoveTempRelationsCallback(), OverrideStackEntry::searchPath, PGPROC::tempNamespaceId, and WARNING.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

{
    /*
     * If we abort the transaction in which a temp namespace was selected,
     * we'll have to do any creation or cleanout work over again.  So, just
     * forget the namespace entirely until next time.  On the other hand, if
     * we commit then register an exit callback to clean out the temp tables
     * at backend shutdown.  (We only want to register the callback once per
     * session, so this is a good place to do it.)
     */
    if (myTempNamespaceSubID != InvalidSubTransactionId && !parallel)
    {
        if (isCommit)
            before_shmem_exit(RemoveTempRelationsCallback, 0);
        else
        {
            myTempNamespace = InvalidOid;
            myTempToastNamespace = InvalidOid;
            baseSearchPathValid = false;    /* need to rebuild list */

            /*
             * Reset the temporary namespace flag in MyProc.  We assume that
             * this operation is atomic.
             *
             * Because this transaction is aborting, the pg_namespace row is
             * not visible to anyone else anyway, but that doesn't matter:
             * it's not a problem if objects contained in this namespace are
             * removed concurrently.
             */
            MyProc->tempNamespaceId = InvalidOid;
        }
        myTempNamespaceSubID = InvalidSubTransactionId;
    }

    /*
     * Clean up if someone failed to do PopOverrideSearchPath
     */
    if (overrideStack)
    {
        if (isCommit)
            elog(WARNING, "leaked override search path");
        while (overrideStack)
        {
            OverrideStackEntry *entry;

            entry = (OverrideStackEntry *) linitial(overrideStack);
            overrideStack = list_delete_first(overrideStack);
            list_free(entry->searchPath);
            pfree(entry);
        }
        /* If not baseSearchPathValid, this is useless but harmless */
        activeSearchPath = baseSearchPath;
        activeCreationNamespace = baseCreationNamespace;
        activeTempCreationPending = baseTempCreationPending;
        /* Always bump generation --- see note in recomputeNamespacePath */
        activePathGeneration++;
    }
}

check_search_path()

bool check_search_path	(	char **	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 4273 of file namespace.c.

References GUC_check_errdetail, list_free(), pfree(), pstrdup(), and SplitIdentifierString().

{
    char       *rawname;
    List       *namelist;

    /* Need a modifiable copy of string */
    rawname = pstrdup(*newval);

    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawname, ',', &namelist))
    {
        /* syntax error in name list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawname);
        list_free(namelist);
        return false;
    }

    /*
     * We used to try to check that the named schemas exist, but there are
     * many valid use-cases for having search_path settings that include
     * schemas that don't exist; and often, we are not inside a transaction
     * here and so can't consult the system catalogs anyway.  So now, the only
     * requirement is syntactic validity of the identifier list.
     */

    pfree(rawname);
    list_free(namelist);

    return true;
}

CheckSetNamespace()

void CheckSetNamespace	(	Oid	oldNspOid,
		Oid	nspOid
	)

Definition at line 2966 of file namespace.c.

References ereport, errcode(), errmsg(), ERROR, and isAnyTempNamespace().

Referenced by AlterObjectNamespace_internal(), AlterTableNamespace(), and AlterTypeNamespaceInternal().

{
    /* disallow renaming into or out of temp schemas */
    if (isAnyTempNamespace(nspOid) || isAnyTempNamespace(oldNspOid))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot move objects into or out of temporary schemas")));

    /* same for TOAST schema */
    if (nspOid == PG_TOAST_NAMESPACE || oldNspOid == PG_TOAST_NAMESPACE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot move objects into or out of TOAST schema")));
}

checkTempNamespaceStatus()

TempNamespaceStatus checkTempNamespaceStatus

(

Oid

namespaceId

)

Definition at line 3236 of file namespace.c.

References Assert, BackendIdGetProc(), PGPROC::databaseId, GetTempNamespaceBackendId(), InvalidBackendId, MyDatabaseId, OidIsValid, TEMP_NAMESPACE_IDLE, TEMP_NAMESPACE_IN_USE, TEMP_NAMESPACE_NOT_TEMP, and PGPROC::tempNamespaceId.

Referenced by do_autovacuum().

{
    PGPROC     *proc;
    int         backendId;

    Assert(OidIsValid(MyDatabaseId));

    backendId = GetTempNamespaceBackendId(namespaceId);

    /* No such namespace, or its name shows it's not temp? */
    if (backendId == InvalidBackendId)
        return TEMP_NAMESPACE_NOT_TEMP;

    /* Is the backend alive? */
    proc = BackendIdGetProc(backendId);
    if (proc == NULL)
        return TEMP_NAMESPACE_IDLE;

    /* Is the backend connected to the same database we are looking at? */
    if (proc->databaseId != MyDatabaseId)
        return TEMP_NAMESPACE_IDLE;

    /* Does the backend own the temporary namespace? */
    if (proc->tempNamespaceId != namespaceId)
        return TEMP_NAMESPACE_IDLE;

    /* Yup, so namespace is busy */
    return TEMP_NAMESPACE_IN_USE;
}

CollationGetCollid()

Oid CollationGetCollid

(

const char *

collname

)

Definition at line 2013 of file namespace.c.

References GetDatabaseEncoding(), InvalidOid, lfirst_oid, lookup_collation(), myTempNamespace, OidIsValid, and recomputeNamespacePath().

Referenced by CollationIsVisible().

{
    int32       dbencoding = GetDatabaseEncoding();
    ListCell   *l;

    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);
        Oid         collid;

        if (namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */

        collid = lookup_collation(collname, namespaceId, dbencoding);
        if (OidIsValid(collid))
            return collid;
    }

    /* Not found in path */
    return InvalidOid;
}

CollationIsVisible()

bool CollationIsVisible

(

Oid

collid

)

Definition at line 2047 of file namespace.c.

References CollationGetCollid(), COLLOID, elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum, recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by generate_collation_name(), getObjectDescription(), pg_collation_is_visible(), and regcollationout().

{
    HeapTuple   colltup;
    Form_pg_collation collform;
    Oid         collnamespace;
    bool        visible;

    colltup = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
    if (!HeapTupleIsValid(colltup))
        elog(ERROR, "cache lookup failed for collation %u", collid);
    collform = (Form_pg_collation) GETSTRUCT(colltup);

    recomputeNamespacePath();

    /*
     * Quick check: if it ain't in the path at all, it ain't visible. Items in
     * the system namespace are surely in the path and so we needn't even do
     * list_member_oid() for them.
     */
    collnamespace = collform->collnamespace;
    if (collnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, collnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another collation of the same name earlier in the path,
         * or it might not work with the current DB encoding.  So we must do a
         * slow check to see if this collation would be found by
         * CollationGetCollid.
         */
        char       *collname = NameStr(collform->collname);

        visible = (CollationGetCollid(collname) == collid);
    }

    ReleaseSysCache(colltup);

    return visible;
}

ConversionGetConid()

Oid ConversionGetConid

(

const char *

conname

)

Definition at line 2098 of file namespace.c.

References CONNAMENSP, GetSysCacheOid2, InvalidOid, lfirst_oid, myTempNamespace, ObjectIdGetDatum, OidIsValid, PointerGetDatum, and recomputeNamespacePath().

Referenced by ConversionIsVisible().

{
    Oid         conid;
    ListCell   *l;

    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);

        if (namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */

        conid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
                                PointerGetDatum(conname),
                                ObjectIdGetDatum(namespaceId));
        if (OidIsValid(conid))
            return conid;
    }

    /* Not found in path */
    return InvalidOid;
}

ConversionIsVisible()

bool ConversionIsVisible

(

Oid

conid

)

Definition at line 2130 of file namespace.c.

References ConversionGetConid(), CONVOID, elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum, recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getObjectDescription(), and pg_conversion_is_visible().

{
    HeapTuple   contup;
    Form_pg_conversion conform;
    Oid         connamespace;
    bool        visible;

    contup = SearchSysCache1(CONVOID, ObjectIdGetDatum(conid));
    if (!HeapTupleIsValid(contup))
        elog(ERROR, "cache lookup failed for conversion %u", conid);
    conform = (Form_pg_conversion) GETSTRUCT(contup);

    recomputeNamespacePath();

    /*
     * Quick check: if it ain't in the path at all, it ain't visible. Items in
     * the system namespace are surely in the path and so we needn't even do
     * list_member_oid() for them.
     */
    connamespace = conform->connamespace;
    if (connamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, connamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another conversion of the same name earlier in the path.
         * So we must do a slow check to see if this conversion would be found
         * by ConversionGetConid.
         */
        char       *conname = NameStr(conform->conname);

        visible = (ConversionGetConid(conname) == conid);
    }

    ReleaseSysCache(contup);

    return visible;
}

CopyOverrideSearchPath()

OverrideSearchPath* CopyOverrideSearchPath

(

OverrideSearchPath *

path

)

Definition at line 3396 of file namespace.c.

References OverrideSearchPath::addCatalog, OverrideSearchPath::addTemp, OverrideSearchPath::generation, list_copy(), palloc(), and OverrideSearchPath::schemas.

Referenced by CopyCachedPlan().

{
    OverrideSearchPath *result;

    result = (OverrideSearchPath *) palloc(sizeof(OverrideSearchPath));
    result->schemas = list_copy(path->schemas);
    result->addCatalog = path->addCatalog;
    result->addTemp = path->addTemp;
    result->generation = path->generation;

    return result;
}

DeconstructQualifiedName()

void DeconstructQualifiedName	(	List *	names,
		char **	nspname_p,
		char **	objname_p
	)

Definition at line 2808 of file namespace.c.

References ereport, errcode(), errmsg(), ERROR, get_database_name(), linitial, list_length(), lsecond, lthird, MyDatabaseId, NameListToString(), and strVal.

Referenced by AlterStatistics(), FuncnameGetCandidates(), get_collation_oid(), get_conversion_oid(), get_statistics_object_oid(), get_ts_config_oid(), get_ts_dict_oid(), get_ts_parser_oid(), get_ts_template_oid(), LookupTypeNameExtended(), make_oper_cache_key(), OpClassCacheLookup(), OpernameGetCandidates(), OpernameGetOprid(), OpFamilyCacheLookup(), QualifiedNameGetCreationNamespace(), and ResolveOpClass().

{
    char       *catalogname;
    char       *schemaname = NULL;
    char       *objname = NULL;

    switch (list_length(names))
    {
        case 1:
            objname = strVal(linitial(names));
            break;
        case 2:
            schemaname = strVal(linitial(names));
            objname = strVal(lsecond(names));
            break;
        case 3:
            catalogname = strVal(linitial(names));
            schemaname = strVal(lsecond(names));
            objname = strVal(lthird(names));

            /*
             * We check the catalog name and then ignore it.
             */
            if (strcmp(catalogname, get_database_name(MyDatabaseId)) != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cross-database references are not implemented: %s",
                                NameListToString(names))));
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("improper qualified name (too many dotted names): %s",
                            NameListToString(names))));
            break;
    }

    *nspname_p = schemaname;
    *objname_p = objname;
}

fetch_search_path()

List* fetch_search_path

(

bool

includeImplicit

)

Definition at line 4382 of file namespace.c.

References AccessTempTableNamespace(), activeCreationNamespace, activeTempCreationPending, linitial_oid, list_copy(), list_delete_first(), and recomputeNamespacePath().

Referenced by AfterTriggerSetState(), CreateExtensionInternal(), current_schema(), and current_schemas().

{
    List       *result;

    recomputeNamespacePath();

    /*
     * If the temp namespace should be first, force it to exist.  This is so
     * that callers can trust the result to reflect the actual default
     * creation namespace.  It's a bit bogus to do this here, since
     * current_schema() is supposedly a stable function without side-effects,
     * but the alternatives seem worse.
     */
    if (activeTempCreationPending)
    {
        AccessTempTableNamespace(true);
        recomputeNamespacePath();
    }

    result = list_copy(activeSearchPath);
    if (!includeImplicit)
    {
        while (result && linitial_oid(result) != activeCreationNamespace)
            result = list_delete_first(result);
    }

    return result;
}

fetch_search_path_array()

int fetch_search_path_array	(	Oid *	sarray,
		int	sarray_len
	)

Definition at line 4422 of file namespace.c.

References lfirst_oid, myTempNamespace, and recomputeNamespacePath().

Referenced by make_oper_cache_key().

{
    int         count = 0;
    ListCell   *l;

    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);

        if (namespaceId == myTempNamespace)
            continue;           /* do not include temp namespace */

        if (count < sarray_len)
            sarray[count] = namespaceId;
        count++;
    }

    return count;
}

FindDefaultConversionProc()

Oid FindDefaultConversionProc	(	int32	for_encoding,
		int32	to_encoding
	)

Definition at line 3709 of file namespace.c.

References FindDefaultConversion(), InvalidOid, lfirst_oid, myTempNamespace, OidIsValid, and recomputeNamespacePath().

Referenced by InitializeClientEncoding(), pg_do_encoding_conversion(), and PrepareClientEncoding().

{
    Oid         proc;
    ListCell   *l;

    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);

        if (namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */

        proc = FindDefaultConversion(namespaceId, for_encoding, to_encoding);
        if (OidIsValid(proc))
            return proc;
    }

    /* Not found in path */
    return InvalidOid;
}

FuncnameGetCandidates()

FuncCandidateList FuncnameGetCandidates	(	List *	names,
		int	nargs,
		List *	argnames,
		bool	expand_variadic,
		bool	expand_defaults,
		bool	missing_ok
	)

Definition at line 942 of file namespace.c.

References _FuncCandidateList::argnumbers, _FuncCandidateList::args, generate_unaccent_rules::args, Assert, CStringGetDatum, DeconstructQualifiedName(), GETSTRUCT, i, InvalidOid, lfirst_oid, LookupExplicitNamespace(), MatchNamedCall(), Max, catclist::members, myTempNamespace, catclist::n_members, _FuncCandidateList::nargs, _FuncCandidateList::ndargs, _FuncCandidateList::next, NIL, _FuncCandidateList::nvargs, offsetof, _FuncCandidateList::oid, OidIsValid, catclist::ordered, palloc(), _FuncCandidateList::pathpos, pfree(), PROCNAMEARGSNSP, pronargs, recomputeNamespacePath(), ReleaseSysCacheList, SearchSysCacheList1, and catctup::tuple.

Referenced by func_get_detail(), FunctionIsVisible(), LookupFuncNameInternal(), regprocedurein(), regprocin(), regprocout(), to_regproc(), and to_regprocedure().

{
    FuncCandidateList resultList = NULL;
    bool        any_special = false;
    char       *schemaname;
    char       *funcname;
    Oid         namespaceId;
    CatCList   *catlist;
    int         i;

    /* check for caller error */
    Assert(nargs >= 0 || !(expand_variadic | expand_defaults));

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &funcname);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (!OidIsValid(namespaceId))
            return NULL;
    }
    else
    {
        /* flag to indicate we need namespace search */
        namespaceId = InvalidOid;
        recomputeNamespacePath();
    }

    /* Search syscache by name only */
    catlist = SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(funcname));

    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   proctup = &catlist->members[i]->tuple;
        Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
        int         pronargs = procform->pronargs;
        int         effective_nargs;
        int         pathpos = 0;
        bool        variadic;
        bool        use_defaults;
        Oid         va_elem_type;
        int        *argnumbers = NULL;
        FuncCandidateList newResult;

        if (OidIsValid(namespaceId))
        {
            /* Consider only procs in specified namespace */
            if (procform->pronamespace != namespaceId)
                continue;
        }
        else
        {
            /*
             * Consider only procs that are in the search path and are not in
             * the temp namespace.
             */
            ListCell   *nsp;

            foreach(nsp, activeSearchPath)
            {
                if (procform->pronamespace == lfirst_oid(nsp) &&
                    procform->pronamespace != myTempNamespace)
                    break;
                pathpos++;
            }
            if (nsp == NULL)
                continue;       /* proc is not in search path */
        }

        if (argnames != NIL)
        {
            /*
             * Call uses named or mixed notation
             *
             * Named or mixed notation can match a variadic function only if
             * expand_variadic is off; otherwise there is no way to match the
             * presumed-nameless parameters expanded from the variadic array.
             */
            if (OidIsValid(procform->provariadic) && expand_variadic)
                continue;
            va_elem_type = InvalidOid;
            variadic = false;

            /*
             * Check argument count.
             */
            Assert(nargs >= 0); /* -1 not supported with argnames */

            if (pronargs > nargs && expand_defaults)
            {
                /* Ignore if not enough default expressions */
                if (nargs + procform->pronargdefaults < pronargs)
                    continue;
                use_defaults = true;
            }
            else
                use_defaults = false;

            /* Ignore if it doesn't match requested argument count */
            if (pronargs != nargs && !use_defaults)
                continue;

            /* Check for argument name match, generate positional mapping */
            if (!MatchNamedCall(proctup, nargs, argnames,
                                &argnumbers))
                continue;

            /* Named argument matching is always "special" */
            any_special = true;
        }
        else
        {
            /*
             * Call uses positional notation
             *
             * Check if function is variadic, and get variadic element type if
             * so.  If expand_variadic is false, we should just ignore
             * variadic-ness.
             */
            if (pronargs <= nargs && expand_variadic)
            {
                va_elem_type = procform->provariadic;
                variadic = OidIsValid(va_elem_type);
                any_special |= variadic;
            }
            else
            {
                va_elem_type = InvalidOid;
                variadic = false;
            }

            /*
             * Check if function can match by using parameter defaults.
             */
            if (pronargs > nargs && expand_defaults)
            {
                /* Ignore if not enough default expressions */
                if (nargs + procform->pronargdefaults < pronargs)
                    continue;
                use_defaults = true;
                any_special = true;
            }
            else
                use_defaults = false;

            /* Ignore if it doesn't match requested argument count */
            if (nargs >= 0 && pronargs != nargs && !variadic && !use_defaults)
                continue;
        }

        /*
         * We must compute the effective argument list so that we can easily
         * compare it to earlier results.  We waste a palloc cycle if it gets
         * masked by an earlier result, but really that's a pretty infrequent
         * case so it's not worth worrying about.
         */
        effective_nargs = Max(pronargs, nargs);
        newResult = (FuncCandidateList)
            palloc(offsetof(struct _FuncCandidateList, args) +
                   effective_nargs * sizeof(Oid));
        newResult->pathpos = pathpos;
        newResult->oid = procform->oid;
        newResult->nargs = effective_nargs;
        newResult->argnumbers = argnumbers;
        if (argnumbers)
        {
            /* Re-order the argument types into call's logical order */
            Oid        *proargtypes = procform->proargtypes.values;
            int         i;

            for (i = 0; i < pronargs; i++)
                newResult->args[i] = proargtypes[argnumbers[i]];
        }
        else
        {
            /* Simple positional case, just copy proargtypes as-is */
            memcpy(newResult->args, procform->proargtypes.values,
                   pronargs * sizeof(Oid));
        }
        if (variadic)
        {
            int         i;

            newResult->nvargs = effective_nargs - pronargs + 1;
            /* Expand variadic argument into N copies of element type */
            for (i = pronargs - 1; i < effective_nargs; i++)
                newResult->args[i] = va_elem_type;
        }
        else
            newResult->nvargs = 0;
        newResult->ndargs = use_defaults ? pronargs - nargs : 0;

        /*
         * Does it have the same arguments as something we already accepted?
         * If so, decide what to do to avoid returning duplicate argument
         * lists.  We can skip this check for the single-namespace case if no
         * special (named, variadic or defaults) match has been made, since
         * then the unique index on pg_proc guarantees all the matches have
         * different argument lists.
         */
        if (resultList != NULL &&
            (any_special || !OidIsValid(namespaceId)))
        {
            /*
             * If we have an ordered list from SearchSysCacheList (the normal
             * case), then any conflicting proc must immediately adjoin this
             * one in the list, so we only need to look at the newest result
             * item.  If we have an unordered list, we have to scan the whole
             * result list.  Also, if either the current candidate or any
             * previous candidate is a special match, we can't assume that
             * conflicts are adjacent.
             *
             * We ignore defaulted arguments in deciding what is a match.
             */
            FuncCandidateList prevResult;

            if (catlist->ordered && !any_special)
            {
                /* ndargs must be 0 if !any_special */
                if (effective_nargs == resultList->nargs &&
                    memcmp(newResult->args,
                           resultList->args,
                           effective_nargs * sizeof(Oid)) == 0)
                    prevResult = resultList;
                else
                    prevResult = NULL;
            }
            else
            {
                int         cmp_nargs = newResult->nargs - newResult->ndargs;

                for (prevResult = resultList;
                     prevResult;
                     prevResult = prevResult->next)
                {
                    if (cmp_nargs == prevResult->nargs - prevResult->ndargs &&
                        memcmp(newResult->args,
                               prevResult->args,
                               cmp_nargs * sizeof(Oid)) == 0)
                        break;
                }
            }

            if (prevResult)
            {
                /*
                 * We have a match with a previous result.  Decide which one
                 * to keep, or mark it ambiguous if we can't decide.  The
                 * logic here is preference > 0 means prefer the old result,
                 * preference < 0 means prefer the new, preference = 0 means
                 * ambiguous.
                 */
                int         preference;

                if (pathpos != prevResult->pathpos)
                {
                    /*
                     * Prefer the one that's earlier in the search path.
                     */
                    preference = pathpos - prevResult->pathpos;
                }
                else if (variadic && prevResult->nvargs == 0)
                {
                    /*
                     * With variadic functions we could have, for example,
                     * both foo(numeric) and foo(variadic numeric[]) in the
                     * same namespace; if so we prefer the non-variadic match
                     * on efficiency grounds.
                     */
                    preference = 1;
                }
                else if (!variadic && prevResult->nvargs > 0)
                {
                    preference = -1;
                }
                else
                {
                    /*----------
                     * We can't decide.  This can happen with, for example,
                     * both foo(numeric, variadic numeric[]) and
                     * foo(variadic numeric[]) in the same namespace, or
                     * both foo(int) and foo (int, int default something)
                     * in the same namespace, or both foo(a int, b text)
                     * and foo(b text, a int) in the same namespace.
                     *----------
                     */
                    preference = 0;
                }

                if (preference > 0)
                {
                    /* keep previous result */
                    pfree(newResult);
                    continue;
                }
                else if (preference < 0)
                {
                    /* remove previous result from the list */
                    if (prevResult == resultList)
                        resultList = prevResult->next;
                    else
                    {
                        FuncCandidateList prevPrevResult;

                        for (prevPrevResult = resultList;
                             prevPrevResult;
                             prevPrevResult = prevPrevResult->next)
                        {
                            if (prevResult == prevPrevResult->next)
                            {
                                prevPrevResult->next = prevResult->next;
                                break;
                            }
                        }
                        Assert(prevPrevResult); /* assert we found it */
                    }
                    pfree(prevResult);
                    /* fall through to add newResult to list */
                }
                else
                {
                    /* mark old result as ambiguous, discard new */
                    prevResult->oid = InvalidOid;
                    pfree(newResult);
                    continue;
                }
            }
        }

        /*
         * Okay to add it to result list
         */
        newResult->next = resultList;
        resultList = newResult;
    }

    ReleaseSysCacheList(catlist);

    return resultList;
}

FunctionIsVisible()

bool FunctionIsVisible

(

Oid

funcid

)

Definition at line 1413 of file namespace.c.

References _FuncCandidateList::args, elog, ERROR, FuncnameGetCandidates(), GETSTRUCT, HeapTupleIsValid, list_make1, list_member_oid(), makeString(), NameStr, _FuncCandidateList::next, NIL, ObjectIdGetDatum, _FuncCandidateList::oid, PROCOID, proname, recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by format_procedure_extended(), and pg_function_is_visible().

{
    HeapTuple   proctup;
    Form_pg_proc procform;
    Oid         pronamespace;
    bool        visible;

    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(proctup))
        elog(ERROR, "cache lookup failed for function %u", funcid);
    procform = (Form_pg_proc) GETSTRUCT(proctup);

    recomputeNamespacePath();

    /*
     * Quick check: if it ain't in the path at all, it ain't visible. Items in
     * the system namespace are surely in the path and so we needn't even do
     * list_member_oid() for them.
     */
    pronamespace = procform->pronamespace;
    if (pronamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, pronamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another proc of the same name and arguments earlier in
         * the path.  So we must do a slow check to see if this is the same
         * proc that would be found by FuncnameGetCandidates.
         */
        char       *proname = NameStr(procform->proname);
        int         nargs = procform->pronargs;
        FuncCandidateList clist;

        visible = false;

        clist = FuncnameGetCandidates(list_make1(makeString(proname)),
                                      nargs, NIL, false, false, false);

        for (; clist; clist = clist->next)
        {
            if (memcmp(clist->args, procform->proargtypes.values,
                       nargs * sizeof(Oid)) == 0)
            {
                /* Found the expected entry; is it the right proc? */
                visible = (clist->oid == funcid);
                break;
            }
        }
    }

    ReleaseSysCache(proctup);

    return visible;
}

get_collation_oid()

Oid get_collation_oid	(	List *	name,
		bool	missing_ok
	)

Definition at line 3600 of file namespace.c.

References DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetDatabaseEncoding(), GetDatabaseEncodingName(), InvalidOid, lfirst_oid, lookup_collation(), LookupExplicitNamespace(), myTempNamespace, NameListToString(), OidIsValid, and recomputeNamespacePath().

Referenced by AlterCollation(), ComputeIndexAttrs(), ComputePartitionAttrs(), DefineCollation(), DefineDomain(), DefineRange(), get_object_address(), LookupCollation(), regcollationin(), and to_regcollation().

{
    char       *schemaname;
    char       *collation_name;
    int32       dbencoding = GetDatabaseEncoding();
    Oid         namespaceId;
    Oid         colloid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(name, &schemaname, &collation_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            return InvalidOid;

        colloid = lookup_collation(collation_name, namespaceId, dbencoding);
        if (OidIsValid(colloid))
            return colloid;
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */

            colloid = lookup_collation(collation_name, namespaceId, dbencoding);
            if (OidIsValid(colloid))
                return colloid;
        }
    }

    /* Not found in path */
    if (!missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("collation \"%s\" for encoding \"%s\" does not exist",
                        NameListToString(name), GetDatabaseEncodingName())));
    return InvalidOid;
}

get_conversion_oid()

Oid get_conversion_oid	(	List *	name,
		bool	missing_ok
	)

Definition at line 3654 of file namespace.c.

References CONNAMENSP, DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, NameListToString(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, and recomputeNamespacePath().

Referenced by get_object_address().

{
    char       *schemaname;
    char       *conversion_name;
    Oid         namespaceId;
    Oid         conoid = InvalidOid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(name, &schemaname, &conversion_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            conoid = InvalidOid;
        else
            conoid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
                                     PointerGetDatum(conversion_name),
                                     ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */

            conoid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
                                     PointerGetDatum(conversion_name),
                                     ObjectIdGetDatum(namespaceId));
            if (OidIsValid(conoid))
                return conoid;
        }
    }

    /* Not found in path */
    if (!OidIsValid(conoid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("conversion \"%s\" does not exist",
                        NameListToString(name))));
    return conoid;
}

get_namespace_oid()

Oid get_namespace_oid	(	const char *	nspname,
		bool	missing_ok
	)

Definition at line 3042 of file namespace.c.

References CStringGetDatum, ereport, errcode(), errmsg(), ERROR, GetSysCacheOid1, NAMESPACENAME, and OidIsValid.

Referenced by binary_upgrade_create_empty_extension(), convert_schema_name(), CreateExtensionInternal(), get_object_address_defacl(), get_object_address_unqualified(), InitTempTableNamespace(), LookupCreationNamespace(), LookupExplicitNamespace(), LookupNamespaceNoError(), objectNamesToOids(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), recomputeNamespacePath(), regnamespacein(), ReindexMultipleTables(), RenameSchema(), SetDefaultACLsInSchemas(), and to_regnamespace().

{
    Oid         oid;

    oid = GetSysCacheOid1(NAMESPACENAME, Anum_pg_namespace_oid,
                          CStringGetDatum(nspname));
    if (!OidIsValid(oid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_SCHEMA),
                 errmsg("schema \"%s\" does not exist", nspname)));

    return oid;
}

get_statistics_object_oid()

Oid get_statistics_object_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2177 of file namespace.c.

References DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, NameListToString(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, recomputeNamespacePath(), and STATEXTNAMENSP.

Referenced by AlterStatistics(), and get_object_address().

{
    char       *schemaname;
    char       *stats_name;
    Oid         namespaceId;
    Oid         stats_oid = InvalidOid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &stats_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            stats_oid = InvalidOid;
        else
            stats_oid = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
                                        PointerGetDatum(stats_name),
                                        ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */
            stats_oid = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
                                        PointerGetDatum(stats_name),
                                        ObjectIdGetDatum(namespaceId));
            if (OidIsValid(stats_oid))
                break;
        }
    }

    if (!OidIsValid(stats_oid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("statistics object \"%s\" does not exist",
                        NameListToString(names))));

    return stats_oid;
}

get_ts_config_oid()

Oid get_ts_config_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2678 of file namespace.c.

References DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, NameListToString(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, recomputeNamespacePath(), and TSCONFIGNAMENSP.

Referenced by check_TSCurrentConfig(), DefineTSConfiguration(), get_object_address(), GetTSConfigTuple(), getTSCurrentConfig(), regconfigin(), and tsvector_update_trigger().

{
    char       *schemaname;
    char       *config_name;
    Oid         namespaceId;
    Oid         cfgoid = InvalidOid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &config_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            cfgoid = InvalidOid;
        else
            cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP, Anum_pg_ts_config_oid,
                                     PointerGetDatum(config_name),
                                     ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */

            cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP, Anum_pg_ts_config_oid,
                                     PointerGetDatum(config_name),
                                     ObjectIdGetDatum(namespaceId));
            if (OidIsValid(cfgoid))
                break;
        }
    }

    if (!OidIsValid(cfgoid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search configuration \"%s\" does not exist",
                        NameListToString(names))));

    return cfgoid;
}

get_ts_dict_oid()

Oid get_ts_dict_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2425 of file namespace.c.

References DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, NameListToString(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, recomputeNamespacePath(), and TSDICTNAMENSP.

Referenced by AlterTSDictionary(), get_object_address(), MakeConfigurationMapping(), regdictionaryin(), and thesaurus_init().

{
    char       *schemaname;
    char       *dict_name;
    Oid         namespaceId;
    Oid         dictoid = InvalidOid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &dict_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            dictoid = InvalidOid;
        else
            dictoid = GetSysCacheOid2(TSDICTNAMENSP, Anum_pg_ts_dict_oid,
                                      PointerGetDatum(dict_name),
                                      ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */

            dictoid = GetSysCacheOid2(TSDICTNAMENSP, Anum_pg_ts_dict_oid,
                                      PointerGetDatum(dict_name),
                                      ObjectIdGetDatum(namespaceId));
            if (OidIsValid(dictoid))
                break;
        }
    }

    if (!OidIsValid(dictoid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search dictionary \"%s\" does not exist",
                        NameListToString(names))));

    return dictoid;
}

get_ts_parser_oid()

Oid get_ts_parser_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2299 of file namespace.c.

References DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, NameListToString(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, recomputeNamespacePath(), and TSPARSERNAMENSP.

Referenced by DefineTSConfiguration(), get_object_address(), ts_parse_byname(), and ts_token_type_byname().

{
    char       *schemaname;
    char       *parser_name;
    Oid         namespaceId;
    Oid         prsoid = InvalidOid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &parser_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            prsoid = InvalidOid;
        else
            prsoid = GetSysCacheOid2(TSPARSERNAMENSP, Anum_pg_ts_parser_oid,
                                     PointerGetDatum(parser_name),
                                     ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */

            prsoid = GetSysCacheOid2(TSPARSERNAMENSP, Anum_pg_ts_parser_oid,
                                     PointerGetDatum(parser_name),
                                     ObjectIdGetDatum(namespaceId));
            if (OidIsValid(prsoid))
                break;
        }
    }

    if (!OidIsValid(prsoid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search parser \"%s\" does not exist",
                        NameListToString(names))));

    return prsoid;
}

get_ts_template_oid()

Oid get_ts_template_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2552 of file namespace.c.

References DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, NameListToString(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, recomputeNamespacePath(), and TSTEMPLATENAMENSP.

Referenced by DefineTSDictionary(), and get_object_address().

{
    char       *schemaname;
    char       *template_name;
    Oid         namespaceId;
    Oid         tmploid = InvalidOid;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &template_name);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
        if (missing_ok && !OidIsValid(namespaceId))
            tmploid = InvalidOid;
        else
            tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP, Anum_pg_ts_template_oid,
                                      PointerGetDatum(template_name),
                                      ObjectIdGetDatum(namespaceId));
    }
    else
    {
        /* search for it in search path */
        recomputeNamespacePath();

        foreach(l, activeSearchPath)
        {
            namespaceId = lfirst_oid(l);

            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */

            tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP, Anum_pg_ts_template_oid,
                                      PointerGetDatum(template_name),
                                      ObjectIdGetDatum(namespaceId));
            if (OidIsValid(tmploid))
                break;
        }
    }

    if (!OidIsValid(tmploid) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search template \"%s\" does not exist",
                        NameListToString(names))));

    return tmploid;
}

GetOverrideSearchPath()

OverrideSearchPath* GetOverrideSearchPath

(

MemoryContext

context

)

Definition at line 3359 of file namespace.c.

References activeCreationNamespace, activePathGeneration, OverrideSearchPath::addCatalog, OverrideSearchPath::addTemp, Assert, OverrideSearchPath::generation, linitial_oid, list_copy(), list_delete_first(), MemoryContextSwitchTo(), myTempNamespace, palloc0(), recomputeNamespacePath(), and OverrideSearchPath::schemas.

Referenced by CompleteCachedPlan(), CreateSchemaCommand(), and RevalidateCachedQuery().

{
    OverrideSearchPath *result;
    List       *schemas;
    MemoryContext oldcxt;

    recomputeNamespacePath();

    oldcxt = MemoryContextSwitchTo(context);

    result = (OverrideSearchPath *) palloc0(sizeof(OverrideSearchPath));
    schemas = list_copy(activeSearchPath);
    while (schemas && linitial_oid(schemas) != activeCreationNamespace)
    {
        if (linitial_oid(schemas) == myTempNamespace)
            result->addTemp = true;
        else
        {
            Assert(linitial_oid(schemas) == PG_CATALOG_NAMESPACE);
            result->addCatalog = true;
        }
        schemas = list_delete_first(schemas);
    }
    result->schemas = schemas;
    result->generation = activePathGeneration;

    MemoryContextSwitchTo(oldcxt);

    return result;
}

GetTempNamespaceBackendId()

int GetTempNamespaceBackendId

(

Oid

namespaceId

)

Definition at line 3273 of file namespace.c.

References get_namespace_name(), InvalidBackendId, and pfree().

Referenced by checkTempNamespaceStatus(), pg_relation_filepath(), and RelationBuildDesc().

{
    int         result;
    char       *nspname;

    /* See if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */
    nspname = get_namespace_name(namespaceId);
    if (!nspname)
        return InvalidBackendId;    /* no such namespace? */
    if (strncmp(nspname, "pg_temp_", 8) == 0)
        result = atoi(nspname + 8);
    else if (strncmp(nspname, "pg_toast_temp_", 14) == 0)
        result = atoi(nspname + 14);
    else
        result = InvalidBackendId;
    pfree(nspname);
    return result;
}

GetTempNamespaceState()

void GetTempNamespaceState	(	Oid *	tempNamespaceId,
		Oid *	tempToastNamespaceId
	)

Definition at line 3312 of file namespace.c.

References myTempNamespace, and myTempToastNamespace.

Referenced by InitializeParallelDSM().

{
    /* Return namespace OIDs, or 0 if session has not created temp namespace */
    *tempNamespaceId = myTempNamespace;
    *tempToastNamespaceId = myTempToastNamespace;
}

GetTempToastNamespace()

Oid GetTempToastNamespace

(

void

)

Definition at line 3298 of file namespace.c.

References Assert, myTempToastNamespace, and OidIsValid.

Referenced by create_toast_table().

{
    Assert(OidIsValid(myTempToastNamespace));
    return myTempToastNamespace;
}

InitializeSearchPath()

void InitializeSearchPath

(

void

)

Definition at line 4323 of file namespace.c.

References activeCreationNamespace, activePathGeneration, activeTempCreationPending, baseCreationNamespace, baseSearchPath, baseSearchPathValid, baseTempCreationPending, CacheRegisterSyscacheCallback(), GetUserId(), IsBootstrapProcessingMode, list_make1_oid, MemoryContextSwitchTo(), NamespaceCallback(), NAMESPACEOID, namespaceUser, and TopMemoryContext.

Referenced by InitPostgres().

{
    if (IsBootstrapProcessingMode())
    {
        /*
         * In bootstrap mode, the search path must be 'pg_catalog' so that
         * tables are created in the proper namespace; ignore the GUC setting.
         */
        MemoryContext oldcxt;

        oldcxt = MemoryContextSwitchTo(TopMemoryContext);
        baseSearchPath = list_make1_oid(PG_CATALOG_NAMESPACE);
        MemoryContextSwitchTo(oldcxt);
        baseCreationNamespace = PG_CATALOG_NAMESPACE;
        baseTempCreationPending = false;
        baseSearchPathValid = true;
        namespaceUser = GetUserId();
        activeSearchPath = baseSearchPath;
        activeCreationNamespace = baseCreationNamespace;
        activeTempCreationPending = baseTempCreationPending;
        activePathGeneration++; /* pro forma */
    }
    else
    {
        /*
         * In normal mode, arrange for a callback on any syscache invalidation
         * of pg_namespace rows.
         */
        CacheRegisterSyscacheCallback(NAMESPACEOID,
                                      NamespaceCallback,
                                      (Datum) 0);
        /* Force search path to be recomputed on next use */
        baseSearchPathValid = false;
    }
}

InitTempTableNamespace()

static void InitTempTableNamespace ( void  )

static

Definition at line 3942 of file namespace.c.

References ACL_CREATE_TEMP, ACLCHECK_OK, Assert, AssertState, baseSearchPathValid, CommandCounterIncrement(), ereport, errcode(), errmsg(), ERROR, get_database_name(), get_namespace_oid(), GetCurrentSubTransactionId(), GetUserId(), InvalidSubTransactionId, IsParallelWorker, MyBackendId, MyDatabaseId, MyProc, myTempNamespace, myTempNamespaceSubID, myTempToastNamespace, NAMEDATALEN, NamespaceCreate(), OidIsValid, pg_database_aclcheck(), RecoveryInProgress(), RemoveTempRelations(), snprintf, and PGPROC::tempNamespaceId.

Referenced by AccessTempTableNamespace().

{
    char        namespaceName[NAMEDATALEN];
    Oid         namespaceId;
    Oid         toastspaceId;

    Assert(!OidIsValid(myTempNamespace));

    /*
     * First, do permission check to see if we are authorized to make temp
     * tables.  We use a nonstandard error message here since "databasename:
     * permission denied" might be a tad cryptic.
     *
     * Note that ACL_CREATE_TEMP rights are rechecked in pg_namespace_aclmask;
     * that's necessary since current user ID could change during the session.
     * But there's no need to make the namespace in the first place until a
     * temp table creation request is made by someone with appropriate rights.
     */
    if (pg_database_aclcheck(MyDatabaseId, GetUserId(),
                             ACL_CREATE_TEMP) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create temporary tables in database \"%s\"",
                        get_database_name(MyDatabaseId))));

    /*
     * Do not allow a Hot Standby session to make temp tables.  Aside from
     * problems with modifying the system catalogs, there is a naming
     * conflict: pg_temp_N belongs to the session with BackendId N on the
     * primary, not to a hot standby session with the same BackendId.  We
     * should not be able to get here anyway due to XactReadOnly checks, but
     * let's just make real sure.  Note that this also backstops various
     * operations that allow XactReadOnly transactions to modify temp tables;
     * they'd need RecoveryInProgress checks if not for this.
     */
    if (RecoveryInProgress())
        ereport(ERROR,
                (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
                 errmsg("cannot create temporary tables during recovery")));

    /* Parallel workers can't create temporary tables, either. */
    if (IsParallelWorker())
        ereport(ERROR,
                (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
                 errmsg("cannot create temporary tables during a parallel operation")));

    snprintf(namespaceName, sizeof(namespaceName), "pg_temp_%d", MyBackendId);

    namespaceId = get_namespace_oid(namespaceName, true);
    if (!OidIsValid(namespaceId))
    {
        /*
         * First use of this temp namespace in this database; create it. The
         * temp namespaces are always owned by the superuser.  We leave their
         * permissions at default --- i.e., no access except to superuser ---
         * to ensure that unprivileged users can't peek at other backends'
         * temp tables.  This works because the places that access the temp
         * namespace for my own backend skip permissions checks on it.
         */
        namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID,
                                      true);
        /* Advance command counter to make namespace visible */
        CommandCounterIncrement();
    }
    else
    {
        /*
         * If the namespace already exists, clean it out (in case the former
         * owner crashed without doing so).
         */
        RemoveTempRelations(namespaceId);
    }

    /*
     * If the corresponding toast-table namespace doesn't exist yet, create
     * it. (We assume there is no need to clean it out if it does exist, since
     * dropping a parent table should make its toast table go away.)
     */
    snprintf(namespaceName, sizeof(namespaceName), "pg_toast_temp_%d",
             MyBackendId);

    toastspaceId = get_namespace_oid(namespaceName, true);
    if (!OidIsValid(toastspaceId))
    {
        toastspaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID,
                                       true);
        /* Advance command counter to make namespace visible */
        CommandCounterIncrement();
    }

    /*
     * Okay, we've prepared the temp namespace ... but it's not committed yet,
     * so all our work could be undone by transaction rollback.  Set flag for
     * AtEOXact_Namespace to know what to do.
     */
    myTempNamespace = namespaceId;
    myTempToastNamespace = toastspaceId;

    /*
     * Mark MyProc as owning this namespace which other processes can use to
     * decide if a temporary namespace is in use or not.  We assume that
     * assignment of namespaceId is an atomic operation.  Even if it is not,
     * the temporary relation which resulted in the creation of this temporary
     * namespace is still locked until the current transaction commits, and
     * its pg_namespace row is not visible yet.  However it does not matter:
     * this flag makes the namespace as being in use, so no objects created on
     * it would be removed concurrently.
     */
    MyProc->tempNamespaceId = namespaceId;

    /* It should not be done already. */
    AssertState(myTempNamespaceSubID == InvalidSubTransactionId);
    myTempNamespaceSubID = GetCurrentSubTransactionId();

    baseSearchPathValid = false;    /* need to rebuild list */
}

isAnyTempNamespace()

bool isAnyTempNamespace

(

Oid

namespaceId

)

Definition at line 3194 of file namespace.c.

References get_namespace_name(), and pfree().

Referenced by AlterTableMoveAll(), CheckSetNamespace(), EventTriggerSQLDropAddObject(), isOtherTempNamespace(), pg_event_trigger_ddl_commands(), and RangeVarAdjustRelationPersistence().

{
    bool        result;
    char       *nspname;

    /* True if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */
    nspname = get_namespace_name(namespaceId);
    if (!nspname)
        return false;           /* no such namespace? */
    result = (strncmp(nspname, "pg_temp_", 8) == 0) ||
        (strncmp(nspname, "pg_toast_temp_", 14) == 0);
    pfree(nspname);
    return result;
}

isOtherTempNamespace()

bool isOtherTempNamespace

(

Oid

namespaceId

)

Definition at line 3217 of file namespace.c.

References isAnyTempNamespace(), and isTempOrTempToastNamespace().

Referenced by pg_is_other_temp_schema().

{
    /* If it's my own temp namespace, say "false" */
    if (isTempOrTempToastNamespace(namespaceId))
        return false;
    /* Else, if it's any temp namespace, say "true" */
    return isAnyTempNamespace(namespaceId);
}

isTempNamespace()

bool isTempNamespace

(

Oid

namespaceId

)

Definition at line 3156 of file namespace.c.

References myTempNamespace, and OidIsValid.

Referenced by CreateExtensionInternal(), EventTriggerSQLDropAddObject(), ExecCheckXactReadOnly(), get_namespace_name_or_temp(), pg_namespace_aclmask(), ReindexMultipleTables(), and RemoveObjects().

{
    if (OidIsValid(myTempNamespace) && myTempNamespace == namespaceId)
        return true;
    return false;
}

isTempOrTempToastNamespace()

bool isTempOrTempToastNamespace

(

Oid

namespaceId

)

Definition at line 3180 of file namespace.c.

References myTempNamespace, myTempToastNamespace, and OidIsValid.

Referenced by create_toast_table(), isOtherTempNamespace(), pg_relation_filepath(), RangeVarAdjustRelationPersistence(), RelationBuildDesc(), and RelationBuildLocalRelation().

{
    if (OidIsValid(myTempNamespace) &&
        (myTempNamespace == namespaceId || myTempToastNamespace == namespaceId))
        return true;
    return false;
}

isTempToastNamespace()

bool isTempToastNamespace

(

Oid

namespaceId

)

Definition at line 3168 of file namespace.c.

References myTempToastNamespace, and OidIsValid.

Referenced by IsToastNamespace().

{
    if (OidIsValid(myTempToastNamespace) && myTempToastNamespace == namespaceId)
        return true;
    return false;
}

lookup_collation()

static Oid lookup_collation ( const char *  collname, Oid  collnamespace, int32  encoding  )

static

Definition at line 1962 of file namespace.c.

References COLLNAMEENCNSP, GETSTRUCT, GetSysCacheOid3, HeapTupleIsValid, Int32GetDatum, InvalidOid, is_encoding_supported_by_icu(), ObjectIdGetDatum, OidIsValid, PointerGetDatum, ReleaseSysCache(), and SearchSysCache3().

Referenced by CollationGetCollid(), and get_collation_oid().

{
    Oid         collid;
    HeapTuple   colltup;
    Form_pg_collation collform;

    /* Check for encoding-specific entry (exact match) */
    collid = GetSysCacheOid3(COLLNAMEENCNSP, Anum_pg_collation_oid,
                             PointerGetDatum(collname),
                             Int32GetDatum(encoding),
                             ObjectIdGetDatum(collnamespace));
    if (OidIsValid(collid))
        return collid;

    /*
     * Check for any-encoding entry.  This takes a bit more work: while libc
     * collations with collencoding = -1 do work with all encodings, ICU
     * collations only work with certain encodings, so we have to check that
     * aspect before deciding it's a match.
     */
    colltup = SearchSysCache3(COLLNAMEENCNSP,
                              PointerGetDatum(collname),
                              Int32GetDatum(-1),
                              ObjectIdGetDatum(collnamespace));
    if (!HeapTupleIsValid(colltup))
        return InvalidOid;
    collform = (Form_pg_collation) GETSTRUCT(colltup);
    if (collform->collprovider == COLLPROVIDER_ICU)
    {
        if (is_encoding_supported_by_icu(encoding))
            collid = collform->oid;
        else
            collid = InvalidOid;
    }
    else
    {
        collid = collform->oid;
    }
    ReleaseSysCache(colltup);
    return collid;
}

LookupCreationNamespace()

Oid LookupCreationNamespace

(

const char *

nspname

)

Definition at line 2935 of file namespace.c.

References AccessTempTableNamespace(), ACL_CREATE, aclcheck_error(), ACLCHECK_OK, get_namespace_oid(), GetUserId(), myTempNamespace, OBJECT_SCHEMA, and pg_namespace_aclcheck().

Referenced by AlterExtensionNamespace(), AlterTypeNamespace(), ExecAlterObjectSchemaStmt(), ImportForeignSchema(), and make_new_heap().

{
    Oid         namespaceId;
    AclResult   aclresult;

    /* check for pg_temp alias */
    if (strcmp(nspname, "pg_temp") == 0)
    {
        /* Initialize temp namespace */
        AccessTempTableNamespace(false);
        return myTempNamespace;
    }

    namespaceId = get_namespace_oid(nspname, false);

    aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       nspname);

    return namespaceId;
}

LookupExplicitNamespace()

Oid LookupExplicitNamespace	(	const char *	nspname,
		bool	missing_ok
	)

Definition at line 2892 of file namespace.c.

References ACL_USAGE, aclcheck_error(), ACLCHECK_OK, get_namespace_oid(), GetUserId(), InvalidOid, InvokeNamespaceSearchHook, myTempNamespace, OBJECT_SCHEMA, OidIsValid, and pg_namespace_aclcheck().

Referenced by AfterTriggerSetState(), FuncnameGetCandidates(), get_collation_oid(), get_conversion_oid(), get_statistics_object_oid(), get_ts_config_oid(), get_ts_dict_oid(), get_ts_parser_oid(), get_ts_template_oid(), LookupTypeNameExtended(), make_oper_cache_key(), objectsInSchemaToOids(), OpClassCacheLookup(), OpernameGetCandidates(), OpernameGetOprid(), OpFamilyCacheLookup(), RangeVarGetRelidExtended(), ResolveOpClass(), schema_to_xml(), schema_to_xml_and_xmlschema(), and schema_to_xmlschema_internal().

{
    Oid         namespaceId;
    AclResult   aclresult;

    /* check for pg_temp alias */
    if (strcmp(nspname, "pg_temp") == 0)
    {
        if (OidIsValid(myTempNamespace))
            return myTempNamespace;

        /*
         * Since this is used only for looking up existing objects, there is
         * no point in trying to initialize the temp namespace here; and doing
         * so might create problems for some callers --- just fall through.
         */
    }

    namespaceId = get_namespace_oid(nspname, missing_ok);
    if (missing_ok && !OidIsValid(namespaceId))
        return InvalidOid;

    aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       nspname);
    /* Schema search hook for this lookup */
    InvokeNamespaceSearchHook(namespaceId, true);

    return namespaceId;
}

LookupNamespaceNoError()

Oid LookupNamespaceNoError

(

const char *

nspname

)

Definition at line 2862 of file namespace.c.

References get_namespace_oid(), InvalidOid, InvokeNamespaceSearchHook, myTempNamespace, and OidIsValid.

Referenced by DropErrorMsgNonExistent(), refnameNamespaceItem(), and schema_does_not_exist_skipping().

{
    /* check for pg_temp alias */
    if (strcmp(nspname, "pg_temp") == 0)
    {
        if (OidIsValid(myTempNamespace))
        {
            InvokeNamespaceSearchHook(myTempNamespace, true);
            return myTempNamespace;
        }

        /*
         * Since this is used only for looking up existing objects, there is
         * no point in trying to initialize the temp namespace here; and doing
         * so might create problems for some callers. Just report "not found".
         */
        return InvalidOid;
    }

    return get_namespace_oid(nspname, true);
}

makeRangeVarFromNameList()

RangeVar* makeRangeVarFromNameList

(

List *

names

)

Definition at line 3061 of file namespace.c.

References RangeVar::catalogname, ereport, errcode(), errmsg(), ERROR, linitial, list_length(), lsecond, lthird, makeRangeVar(), NameListToString(), RangeVar::relname, RangeVar::schemaname, and strVal.

Referenced by bt_metap(), bt_page_items(), bt_page_stats(), convert_table_name(), currtid_byrelname(), generateSerialExtraStmts(), get_object_address_attrdef(), get_object_address_attribute(), get_object_address_publication_rel(), get_object_address_relobject(), get_raw_page_internal(), get_rel_from_relname(), get_relation_by_qualified_name(), nextval(), owningrel_does_not_exist_skipping(), pg_get_serial_sequence(), pg_get_viewdef_name(), pg_get_viewdef_name_ext(), pg_relpages(), pg_relpages_v1_5(), pgrowlocks(), pgstatindex(), pgstatindex_v1_5(), pgstattuple(), pgstattuple_v1_5(), process_owned_by(), regclassin(), RelationNameGetTupleDesc(), RemoveRelations(), row_security_active_name(), schema_does_not_exist_skipping(), text_regclass(), and to_regclass().

{
    RangeVar   *rel = makeRangeVar(NULL, NULL, -1);

    switch (list_length(names))
    {
        case 1:
            rel->relname = strVal(linitial(names));
            break;
        case 2:
            rel->schemaname = strVal(linitial(names));
            rel->relname = strVal(lsecond(names));
            break;
        case 3:
            rel->catalogname = strVal(linitial(names));
            rel->schemaname = strVal(lsecond(names));
            rel->relname = strVal(lthird(names));
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("improper relation name (too many dotted names): %s",
                            NameListToString(names))));
            break;
    }

    return rel;
}

MatchNamedCall()

static bool MatchNamedCall ( HeapTuple  proctup, int  nargs, List *  argnames, int **  argnumbers  )

static

Definition at line 1305 of file namespace.c.

References Assert, FUNC_MAX_ARGS, FUNC_PARAM_IN, FUNC_PARAM_INOUT, FUNC_PARAM_VARIADIC, get_func_arg_info(), GETSTRUCT, i, lfirst, list_length(), NIL, palloc(), PROCOID, pronargs, and SysCacheGetAttr().

Referenced by FuncnameGetCandidates().

{
    Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
    int         pronargs = procform->pronargs;
    int         numposargs = nargs - list_length(argnames);
    int         pronallargs;
    Oid        *p_argtypes;
    char      **p_argnames;
    char       *p_argmodes;
    bool        arggiven[FUNC_MAX_ARGS];
    bool        isnull;
    int         ap;             /* call args position */
    int         pp;             /* proargs position */
    ListCell   *lc;

    Assert(argnames != NIL);
    Assert(numposargs >= 0);
    Assert(nargs <= pronargs);

    /* Ignore this function if its proargnames is null */
    (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_proargnames,
                           &isnull);
    if (isnull)
        return false;

    /* OK, let's extract the argument names and types */
    pronallargs = get_func_arg_info(proctup,
                                    &p_argtypes, &p_argnames, &p_argmodes);
    Assert(p_argnames != NULL);

    /* initialize state for matching */
    *argnumbers = (int *) palloc(pronargs * sizeof(int));
    memset(arggiven, false, pronargs * sizeof(bool));

    /* there are numposargs positional args before the named args */
    for (ap = 0; ap < numposargs; ap++)
    {
        (*argnumbers)[ap] = ap;
        arggiven[ap] = true;
    }

    /* now examine the named args */
    foreach(lc, argnames)
    {
        char       *argname = (char *) lfirst(lc);
        bool        found;
        int         i;

        pp = 0;
        found = false;
        for (i = 0; i < pronallargs; i++)
        {
            /* consider only input parameters */
            if (p_argmodes &&
                (p_argmodes[i] != FUNC_PARAM_IN &&
                 p_argmodes[i] != FUNC_PARAM_INOUT &&
                 p_argmodes[i] != FUNC_PARAM_VARIADIC))
                continue;
            if (p_argnames[i] && strcmp(p_argnames[i], argname) == 0)
            {
                /* fail if argname matches a positional argument */
                if (arggiven[pp])
                    return false;
                arggiven[pp] = true;
                (*argnumbers)[ap] = pp;
                found = true;
                break;
            }
            /* increase pp only for input parameters */
            pp++;
        }
        /* if name isn't in proargnames, fail */
        if (!found)
            return false;
        ap++;
    }

    Assert(ap == nargs);        /* processed all actual parameters */

    /* Check for default arguments */
    if (nargs < pronargs)
    {
        int         first_arg_with_default = pronargs - procform->pronargdefaults;

        for (pp = numposargs; pp < pronargs; pp++)
        {
            if (arggiven[pp])
                continue;
            /* fail if arg not given and no default available */
            if (pp < first_arg_with_default)
                return false;
            (*argnumbers)[ap++] = pp;
        }
    }

    Assert(ap == pronargs);     /* processed all function parameters */

    return true;
}

NameListToQuotedString()

char* NameListToQuotedString

(

List *

names

)

Definition at line 3135 of file namespace.c.

References appendStringInfoChar(), appendStringInfoString(), initStringInfo(), lfirst, list_head(), quote_identifier(), and strVal.

{
    StringInfoData string;
    ListCell   *l;

    initStringInfo(&string);

    foreach(l, names)
    {
        if (l != list_head(names))
            appendStringInfoChar(&string, '.');
        appendStringInfoString(&string, quote_identifier(strVal(lfirst(l))));
    }

    return string.data;
}

NameListToString()

char* NameListToString

(

List *

names

)

Definition at line 3101 of file namespace.c.

References appendStringInfoChar(), appendStringInfoString(), elog, ERROR, initStringInfo(), IsA, lfirst, list_head(), name, nodeTag, and strVal.

Referenced by AggregateCreate(), AlterCollation(), AlterFunction(), AlterStatistics(), AlterTSConfiguration(), AlterTSDictionary(), check_object_ownership(), CreateConversionCommand(), CreateEventTrigger(), CreateProceduralLanguage(), CreateTransform(), CreateTrigger(), DeconstructQualifiedName(), defGetString(), DefineOperator(), DefineType(), does_not_exist_skipping(), dropOperators(), dropProcedures(), ExpandColumnRefStar(), findRangeSubOpclass(), findTypeAnalyzeFunction(), findTypeInputFunction(), findTypeOutputFunction(), findTypeReceiveFunction(), findTypeSendFunction(), findTypeTypmodinFunction(), findTypeTypmodoutFunction(), func_signature_string(), get_collation_oid(), get_conversion_oid(), get_object_address_attrdef(), get_object_address_attribute(), get_statistics_object_oid(), get_ts_config_oid(), get_ts_dict_oid(), get_ts_parser_oid(), get_ts_template_oid(), interpret_func_support(), lookup_fdw_handler_func(), LookupFuncName(), LookupFuncWithArgs(), LookupTypeNameExtended(), makeRangeVarFromNameList(), op_signature_string(), OpClassCacheLookup(), OperatorCreate(), OpFamilyCacheLookup(), owningrel_does_not_exist_skipping(), ParseFuncOrColumn(), plpgsql_post_column_ref(), RemoveObjects(), ResolveOpClass(), storeOperators(), storeProcedures(), transformColumnRef(), transformRangeTableSample(), ValidateJoinEstimator(), and ValidateRestrictionEstimator().

{
    StringInfoData string;
    ListCell   *l;

    initStringInfo(&string);

    foreach(l, names)
    {
        Node       *name = (Node *) lfirst(l);

        if (l != list_head(names))
            appendStringInfoChar(&string, '.');

        if (IsA(name, String))
            appendStringInfoString(&string, strVal(name));
        else if (IsA(name, A_Star))
            appendStringInfoChar(&string, '*');
        else
            elog(ERROR, "unexpected node type in name list: %d",
                 (int) nodeTag(name));
    }

    return string.data;
}

NamespaceCallback()

static void NamespaceCallback ( Datum  arg, int  cacheid, uint32  hashvalue  )

static

Definition at line 4364 of file namespace.c.

References baseSearchPathValid.

Referenced by InitializeSearchPath().

{
    /* Force search path to be recomputed on next use */
    baseSearchPathValid = false;
}

OpclassIsVisible()

bool OpclassIsVisible

(

Oid

opcid

)

Definition at line 1832 of file namespace.c.

References CLAOID, elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum, OpclassnameGetOpcid(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by get_opclass_name(), getObjectDescription(), and pg_opclass_is_visible().

{
    HeapTuple   opctup;
    Form_pg_opclass opcform;
    Oid         opcnamespace;
    bool        visible;

    opctup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opcid));
    if (!HeapTupleIsValid(opctup))
        elog(ERROR, "cache lookup failed for opclass %u", opcid);
    opcform = (Form_pg_opclass) GETSTRUCT(opctup);

    recomputeNamespacePath();

    /*
     * Quick check: if it ain't in the path at all, it ain't visible. Items in
     * the system namespace are surely in the path and so we needn't even do
     * list_member_oid() for them.
     */
    opcnamespace = opcform->opcnamespace;
    if (opcnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, opcnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another opclass of the same name earlier in the path. So
         * we must do a slow check to see if this opclass would be found by
         * OpclassnameGetOpcid.
         */
        char       *opcname = NameStr(opcform->opcname);

        visible = (OpclassnameGetOpcid(opcform->opcmethod, opcname) == opcid);
    }

    ReleaseSysCache(opctup);

    return visible;
}

OpclassnameGetOpcid()

Oid OpclassnameGetOpcid	(	Oid	amid,
		const char *	opcname
	)

Definition at line 1799 of file namespace.c.

References CLAAMNAMENSP, GetSysCacheOid3, InvalidOid, lfirst_oid, myTempNamespace, ObjectIdGetDatum, OidIsValid, PointerGetDatum, and recomputeNamespacePath().

Referenced by OpClassCacheLookup(), OpclassIsVisible(), and ResolveOpClass().

{
    Oid         opcid;
    ListCell   *l;

    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);

        if (namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */

        opcid = GetSysCacheOid3(CLAAMNAMENSP, Anum_pg_opclass_oid,
                                ObjectIdGetDatum(amid),
                                PointerGetDatum(opcname),
                                ObjectIdGetDatum(namespaceId));
        if (OidIsValid(opcid))
            return opcid;
    }

    /* Not found in path */
    return InvalidOid;
}

OperatorIsVisible()

bool OperatorIsVisible

(

Oid

oprid

)

Definition at line 1746 of file namespace.c.

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_make1, list_member_oid(), makeString(), NameStr, ObjectIdGetDatum, OpernameGetOprid(), OPEROID, oprid(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by format_operator_extended(), and pg_operator_is_visible().

{
    HeapTuple   oprtup;
    Form_pg_operator oprform;
    Oid         oprnamespace;
    bool        visible;

    oprtup = SearchSysCache1(OPEROID, ObjectIdGetDatum(oprid));
    if (!HeapTupleIsValid(oprtup))
        elog(ERROR, "cache lookup failed for operator %u", oprid);
    oprform = (Form_pg_operator) GETSTRUCT(oprtup);

    recomputeNamespacePath();

    /*
     * Quick check: if it ain't in the path at all, it ain't visible. Items in
     * the system namespace are surely in the path and so we needn't even do
     * list_member_oid() for them.
     */
    oprnamespace = oprform->oprnamespace;
    if (oprnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, oprnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another operator of the same name and arguments earlier
         * in the path.  So we must do a slow check to see if this is the same
         * operator that would be found by OpernameGetOprid.
         */
        char       *oprname = NameStr(oprform->oprname);

        visible = (OpernameGetOprid(list_make1(makeString(oprname)),
                                    oprform->oprleft, oprform->oprright)
                   == oprid);
    }

    ReleaseSysCache(oprtup);

    return visible;
}

OpernameGetCandidates()

FuncCandidateList OpernameGetCandidates	(	List *	names,
		char	oprkind,
		bool	missing_schema_ok
	)

Definition at line 1586 of file namespace.c.

References _FuncCandidateList::argnumbers, _FuncCandidateList::args, Assert, CStringGetDatum, DeconstructQualifiedName(), GETSTRUCT, i, InvalidOid, lfirst_oid, LookupExplicitNamespace(), catclist::members, myTempNamespace, catclist::n_members, _FuncCandidateList::nargs, _FuncCandidateList::ndargs, _FuncCandidateList::next, _FuncCandidateList::nvargs, _FuncCandidateList::oid, OidIsValid, OPERNAMENSP, catclist::ordered, palloc(), _FuncCandidateList::pathpos, recomputeNamespacePath(), ReleaseSysCacheList, SearchSysCacheList1, SPACE_PER_OP, and catctup::tuple.

Referenced by left_oper(), oper(), regoperin(), regoperout(), and to_regoper().

{
    FuncCandidateList resultList = NULL;
    char       *resultSpace = NULL;
    int         nextResult = 0;
    char       *schemaname;
    char       *opername;
    Oid         namespaceId;
    CatCList   *catlist;
    int         i;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &opername);

    if (schemaname)
    {
        /* use exact schema given */
        namespaceId = LookupExplicitNamespace(schemaname, missing_schema_ok);
        if (missing_schema_ok && !OidIsValid(namespaceId))
            return NULL;
    }
    else
    {
        /* flag to indicate we need namespace search */
        namespaceId = InvalidOid;
        recomputeNamespacePath();
    }

    /* Search syscache by name only */
    catlist = SearchSysCacheList1(OPERNAMENSP, CStringGetDatum(opername));

    /*
     * In typical scenarios, most if not all of the operators found by the
     * catcache search will end up getting returned; and there can be quite a
     * few, for common operator names such as '=' or '+'.  To reduce the time
     * spent in palloc, we allocate the result space as an array large enough
     * to hold all the operators.  The original coding of this routine did a
     * separate palloc for each operator, but profiling revealed that the
     * pallocs used an unreasonably large fraction of parsing time.
     */
#define SPACE_PER_OP MAXALIGN(offsetof(struct _FuncCandidateList, args) + \
                              2 * sizeof(Oid))

    if (catlist->n_members > 0)
        resultSpace = palloc(catlist->n_members * SPACE_PER_OP);

    for (i = 0; i < catlist->n_members; i++)
    {
        HeapTuple   opertup = &catlist->members[i]->tuple;
        Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
        int         pathpos = 0;
        FuncCandidateList newResult;

        /* Ignore operators of wrong kind, if specific kind requested */
        if (oprkind && operform->oprkind != oprkind)
            continue;

        if (OidIsValid(namespaceId))
        {
            /* Consider only opers in specified namespace */
            if (operform->oprnamespace != namespaceId)
                continue;
            /* No need to check args, they must all be different */
        }
        else
        {
            /*
             * Consider only opers that are in the search path and are not in
             * the temp namespace.
             */
            ListCell   *nsp;

            foreach(nsp, activeSearchPath)
            {
                if (operform->oprnamespace == lfirst_oid(nsp) &&
                    operform->oprnamespace != myTempNamespace)
                    break;
                pathpos++;
            }
            if (nsp == NULL)
                continue;       /* oper is not in search path */

            /*
             * Okay, it's in the search path, but does it have the same
             * arguments as something we already accepted?  If so, keep only
             * the one that appears earlier in the search path.
             *
             * If we have an ordered list from SearchSysCacheList (the normal
             * case), then any conflicting oper must immediately adjoin this
             * one in the list, so we only need to look at the newest result
             * item.  If we have an unordered list, we have to scan the whole
             * result list.
             */
            if (resultList)
            {
                FuncCandidateList prevResult;

                if (catlist->ordered)
                {
                    if (operform->oprleft == resultList->args[0] &&
                        operform->oprright == resultList->args[1])
                        prevResult = resultList;
                    else
                        prevResult = NULL;
                }
                else
                {
                    for (prevResult = resultList;
                         prevResult;
                         prevResult = prevResult->next)
                    {
                        if (operform->oprleft == prevResult->args[0] &&
                            operform->oprright == prevResult->args[1])
                            break;
                    }
                }
                if (prevResult)
                {
                    /* We have a match with a previous result */
                    Assert(pathpos != prevResult->pathpos);
                    if (pathpos > prevResult->pathpos)
                        continue;   /* keep previous result */
                    /* replace previous result */
                    prevResult->pathpos = pathpos;
                    prevResult->oid = operform->oid;
                    continue;   /* args are same, of course */
                }
            }
        }

        /*
         * Okay to add it to result list
         */
        newResult = (FuncCandidateList) (resultSpace + nextResult);
        nextResult += SPACE_PER_OP;

        newResult->pathpos = pathpos;
        newResult->oid = operform->oid;
        newResult->nargs = 2;
        newResult->nvargs = 0;
        newResult->ndargs = 0;
        newResult->argnumbers = NULL;
        newResult->args[0] = operform->oprleft;
        newResult->args[1] = operform->oprright;
        newResult->next = resultList;
        resultList = newResult;
    }

    ReleaseSysCacheList(catlist);

    return resultList;
}

OpernameGetOprid()

Oid OpernameGetOprid	(	List *	names,
		Oid	oprleft,
		Oid	oprright
	)

Definition at line 1483 of file namespace.c.

References CStringGetDatum, DeconstructQualifiedName(), GETSTRUCT, HeapTupleIsValid, i, InvalidOid, lfirst_oid, LookupExplicitNamespace(), catclist::members, myTempNamespace, catclist::n_members, ObjectIdGetDatum, OidIsValid, OPERNAMENSP, recomputeNamespacePath(), ReleaseSysCache(), ReleaseSysCacheList, SearchSysCache4(), SearchSysCacheList3, and catctup::tuple.

Referenced by binary_oper_exact(), left_oper(), LookupOperName(), OperatorIsVisible(), regoperatorin(), and to_regoperator().

{
    char       *schemaname;
    char       *opername;
    CatCList   *catlist;
    ListCell   *l;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, &opername);

    if (schemaname)
    {
        /* search only in exact schema given */
        Oid         namespaceId;

        namespaceId = LookupExplicitNamespace(schemaname, true);
        if (OidIsValid(namespaceId))
        {
            HeapTuple   opertup;

            opertup = SearchSysCache4(OPERNAMENSP,
                                      CStringGetDatum(opername),
                                      ObjectIdGetDatum(oprleft),
                                      ObjectIdGetDatum(oprright),
                                      ObjectIdGetDatum(namespaceId));
            if (HeapTupleIsValid(opertup))
            {
                Form_pg_operator operclass = (Form_pg_operator) GETSTRUCT(opertup);
                Oid         result = operclass->oid;

                ReleaseSysCache(opertup);
                return result;
            }
        }

        return InvalidOid;
    }

    /* Search syscache by name and argument types */
    catlist = SearchSysCacheList3(OPERNAMENSP,
                                  CStringGetDatum(opername),
                                  ObjectIdGetDatum(oprleft),
                                  ObjectIdGetDatum(oprright));

    if (catlist->n_members == 0)
    {
        /* no hope, fall out early */
        ReleaseSysCacheList(catlist);
        return InvalidOid;
    }

    /*
     * We have to find the list member that is first in the search path, if
     * there's more than one.  This doubly-nested loop looks ugly, but in
     * practice there should usually be few catlist members.
     */
    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);
        int         i;

        if (namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */

        for (i = 0; i < catlist->n_members; i++)
        {
            HeapTuple   opertup = &catlist->members[i]->tuple;
            Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);

            if (operform->oprnamespace == namespaceId)
            {
                Oid         result = operform->oid;

                ReleaseSysCacheList(catlist);
                return result;
            }
        }
    }

    ReleaseSysCacheList(catlist);
    return InvalidOid;
}

OpfamilyIsVisible()

bool OpfamilyIsVisible

(

Oid

opfid

)

Definition at line 1915 of file namespace.c.

References elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum, OpfamilynameGetOpfid(), OPFAMILYOID, recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by getOpFamilyDescription(), and pg_opfamily_is_visible().

{
    HeapTuple   opftup;
    Form_pg_opfamily opfform;
    Oid         opfnamespace;
    bool        visible;

    opftup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(opftup))
        elog(ERROR, "cache lookup failed for opfamily %u", opfid);
    opfform = (Form_pg_opfamily) GETSTRUCT(opftup);

    recomputeNamespacePath();

    /*
     * Quick check: if it ain't in the path at all, it ain't visible. Items in
     * the system namespace are surely in the path and so we needn't even do
     * list_member_oid() for them.
     */
    opfnamespace = opfform->opfnamespace;
    if (opfnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, opfnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another opfamily of the same name earlier in the path. So
         * we must do a slow check to see if this opfamily would be found by
         * OpfamilynameGetOpfid.
         */
        char       *opfname = NameStr(opfform->opfname);

        visible = (OpfamilynameGetOpfid(opfform->opfmethod, opfname) == opfid);
    }

    ReleaseSysCache(opftup);

    return visible;
}

OpfamilynameGetOpfid()

Oid OpfamilynameGetOpfid	(	Oid	amid,
		const char *	opfname
	)

Definition at line 1882 of file namespace.c.

References GetSysCacheOid3, InvalidOid, lfirst_oid, myTempNamespace, ObjectIdGetDatum, OidIsValid, OPFAMILYAMNAMENSP, PointerGetDatum, and recomputeNamespacePath().

Referenced by OpFamilyCacheLookup(), and OpfamilyIsVisible().

{
    Oid         opfid;
    ListCell   *l;

    recomputeNamespacePath();

    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);

        if (namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */

        opfid = GetSysCacheOid3(OPFAMILYAMNAMENSP, Anum_pg_opfamily_oid,
                                ObjectIdGetDatum(amid),
                                PointerGetDatum(opfname),
                                ObjectIdGetDatum(namespaceId));
        if (OidIsValid(opfid))
            return opfid;
    }

    /* Not found in path */
    return InvalidOid;
}

OverrideSearchPathMatchesCurrent()

bool OverrideSearchPathMatchesCurrent

(

OverrideSearchPath *

path

)

Definition at line 3418 of file namespace.c.

References activeCreationNamespace, activePathGeneration, OverrideSearchPath::addCatalog, OverrideSearchPath::addTemp, OverrideSearchPath::generation, InvalidOid, lfirst_oid, list_head(), lnext(), myTempNamespace, recomputeNamespacePath(), and OverrideSearchPath::schemas.

Referenced by CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), and RevalidateCachedQuery().

{
    ListCell   *lc,
               *lcp;

    recomputeNamespacePath();

    /* Quick out if already known equal to active path. */
    if (path->generation == activePathGeneration)
        return true;

    /* We scan down the activeSearchPath to see if it matches the input. */
    lc = list_head(activeSearchPath);

    /* If path->addTemp, first item should be my temp namespace. */
    if (path->addTemp)
    {
        if (lc && lfirst_oid(lc) == myTempNamespace)
            lc = lnext(activeSearchPath, lc);
        else
            return false;
    }
    /* If path->addCatalog, next item should be pg_catalog. */
    if (path->addCatalog)
    {
        if (lc && lfirst_oid(lc) == PG_CATALOG_NAMESPACE)
            lc = lnext(activeSearchPath, lc);
        else
            return false;
    }
    /* We should now be looking at the activeCreationNamespace. */
    if (activeCreationNamespace != (lc ? lfirst_oid(lc) : InvalidOid))
        return false;
    /* The remainder of activeSearchPath should match path->schemas. */
    foreach(lcp, path->schemas)
    {
        if (lc && lfirst_oid(lc) == lfirst_oid(lcp))
            lc = lnext(activeSearchPath, lc);
        else
            return false;
    }
    if (lc)
        return false;

    /*
     * Update path->generation so that future tests will return quickly, so
     * long as the active search path doesn't change.
     */
    path->generation = activePathGeneration;

    return true;
}

pg_collation_is_visible()

Datum pg_collation_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4525 of file namespace.c.

References CollationIsVisible(), COLLOID, ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(COLLOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(CollationIsVisible(oid));
}

pg_conversion_is_visible()

Datum pg_conversion_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4536 of file namespace.c.

References ConversionIsVisible(), CONVOID, ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(CONVOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(ConversionIsVisible(oid));
}

pg_function_is_visible()

Datum pg_function_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4481 of file namespace.c.

References FunctionIsVisible(), ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, PROCOID, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(PROCOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(FunctionIsVisible(oid));
}

pg_is_other_temp_schema()

Datum pg_is_other_temp_schema

(

PG_FUNCTION_ARGS

)

Definition at line 4608 of file namespace.c.

References isOtherTempNamespace(), PG_GETARG_OID, and PG_RETURN_BOOL.

{
    Oid         oid = PG_GETARG_OID(0);

    PG_RETURN_BOOL(isOtherTempNamespace(oid));
}

pg_my_temp_schema()

Datum pg_my_temp_schema

(

PG_FUNCTION_ARGS

)

Definition at line 4602 of file namespace.c.

References myTempNamespace, and PG_RETURN_OID.

{
    PG_RETURN_OID(myTempNamespace);
}

pg_opclass_is_visible()

Datum pg_opclass_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4503 of file namespace.c.

References CLAOID, ObjectIdGetDatum, OpclassIsVisible(), PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(CLAOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(OpclassIsVisible(oid));
}

pg_operator_is_visible()

Datum pg_operator_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4492 of file namespace.c.

References ObjectIdGetDatum, OperatorIsVisible(), OPEROID, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(OPEROID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(OperatorIsVisible(oid));
}

pg_opfamily_is_visible()

Datum pg_opfamily_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4514 of file namespace.c.

References ObjectIdGetDatum, OpfamilyIsVisible(), OPFAMILYOID, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(OPFAMILYOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(OpfamilyIsVisible(oid));
}

pg_statistics_obj_is_visible()

Datum pg_statistics_obj_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4547 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, SearchSysCacheExists1, STATEXTOID, and StatisticsObjIsVisible().

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(STATEXTOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(StatisticsObjIsVisible(oid));
}

pg_table_is_visible()

Datum pg_table_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4459 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, RelationIsVisible(), RELOID, and SearchSysCacheExists1.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(RelationIsVisible(oid));
}

pg_ts_config_is_visible()

Datum pg_ts_config_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4591 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, SearchSysCacheExists1, TSConfigIsVisible(), and TSCONFIGOID.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(TSCONFIGOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(TSConfigIsVisible(oid));
}

pg_ts_dict_is_visible()

Datum pg_ts_dict_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4569 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, SearchSysCacheExists1, TSDictionaryIsVisible(), and TSDICTOID.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(TSDICTOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(TSDictionaryIsVisible(oid));
}

pg_ts_parser_is_visible()

Datum pg_ts_parser_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4558 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, SearchSysCacheExists1, TSParserIsVisible(), and TSPARSEROID.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(TSPARSEROID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(TSParserIsVisible(oid));
}

pg_ts_template_is_visible()

Datum pg_ts_template_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4580 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, SearchSysCacheExists1, TSTemplateIsVisible(), and TSTEMPLATEOID.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(TSTEMPLATEOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(TSTemplateIsVisible(oid));
}

pg_type_is_visible()

Datum pg_type_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4470 of file namespace.c.

References ObjectIdGetDatum, PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, SearchSysCacheExists1, TypeIsVisible(), and TYPEOID.

{
    Oid         oid = PG_GETARG_OID(0);

    if (!SearchSysCacheExists1(TYPEOID, ObjectIdGetDatum(oid)))
        PG_RETURN_NULL();

    PG_RETURN_BOOL(TypeIsVisible(oid));
}

PopOverrideSearchPath()

void PopOverrideSearchPath

(

void

)

Definition at line 3556 of file namespace.c.

References activeCreationNamespace, activePathGeneration, activeTempCreationPending, baseCreationNamespace, baseSearchPath, baseTempCreationPending, OverrideStackEntry::creationNamespace, elog, ERROR, GetCurrentTransactionNestLevel(), linitial, list_delete_first(), list_free(), OverrideStackEntry::nestLevel, NIL, pfree(), and OverrideStackEntry::searchPath.

Referenced by CreateSchemaCommand().

{
    OverrideStackEntry *entry;

    /* Sanity checks. */
    if (overrideStack == NIL)
        elog(ERROR, "bogus PopOverrideSearchPath call");
    entry = (OverrideStackEntry *) linitial(overrideStack);
    if (entry->nestLevel != GetCurrentTransactionNestLevel())
        elog(ERROR, "bogus PopOverrideSearchPath call");

    /* Pop the stack and free storage. */
    overrideStack = list_delete_first(overrideStack);
    list_free(entry->searchPath);
    pfree(entry);

    /* Activate the next level down. */
    if (overrideStack)
    {
        entry = (OverrideStackEntry *) linitial(overrideStack);
        activeSearchPath = entry->searchPath;
        activeCreationNamespace = entry->creationNamespace;
        activeTempCreationPending = false;  /* XXX is this OK? */
    }
    else
    {
        /* If not baseSearchPathValid, this is useless but harmless */
        activeSearchPath = baseSearchPath;
        activeCreationNamespace = baseCreationNamespace;
        activeTempCreationPending = baseTempCreationPending;
    }

    /* As above, the generation always increments. */
    activePathGeneration++;
}

PushOverrideSearchPath()

void PushOverrideSearchPath

(

OverrideSearchPath *

newpath

)

Definition at line 3489 of file namespace.c.

References activeCreationNamespace, activePathGeneration, activeTempCreationPending, OverrideSearchPath::addCatalog, OverrideSearchPath::addTemp, OverrideStackEntry::creationNamespace, GetCurrentTransactionNestLevel(), InvalidOid, lcons(), lcons_oid(), linitial_oid, list_copy(), MemoryContextSwitchTo(), myTempNamespace, OverrideStackEntry::nestLevel, NIL, OidIsValid, palloc(), OverrideSearchPath::schemas, OverrideStackEntry::searchPath, and TopMemoryContext.

Referenced by CreateSchemaCommand().

{
    OverrideStackEntry *entry;
    List       *oidlist;
    Oid         firstNS;
    MemoryContext oldcxt;

    /*
     * Copy the list for safekeeping, and insert implicitly-searched
     * namespaces as needed.  This code should track recomputeNamespacePath.
     */
    oldcxt = MemoryContextSwitchTo(TopMemoryContext);

    oidlist = list_copy(newpath->schemas);

    /*
     * Remember the first member of the explicit list.
     */
    if (oidlist == NIL)
        firstNS = InvalidOid;
    else
        firstNS = linitial_oid(oidlist);

    /*
     * Add any implicitly-searched namespaces to the list.  Note these go on
     * the front, not the back; also notice that we do not check USAGE
     * permissions for these.
     */
    if (newpath->addCatalog)
        oidlist = lcons_oid(PG_CATALOG_NAMESPACE, oidlist);

    if (newpath->addTemp && OidIsValid(myTempNamespace))
        oidlist = lcons_oid(myTempNamespace, oidlist);

    /*
     * Build the new stack entry, then insert it at the head of the list.
     */
    entry = (OverrideStackEntry *) palloc(sizeof(OverrideStackEntry));
    entry->searchPath = oidlist;
    entry->creationNamespace = firstNS;
    entry->nestLevel = GetCurrentTransactionNestLevel();

    overrideStack = lcons(entry, overrideStack);

    /* And make it active. */
    activeSearchPath = entry->searchPath;
    activeCreationNamespace = entry->creationNamespace;
    activeTempCreationPending = false;  /* XXX is this OK? */

    /*
     * We always increment activePathGeneration when pushing/popping an
     * override path.  In current usage, these actions always change the
     * effective path state, so there's no value in checking to see if it
     * didn't change.
     */
    activePathGeneration++;

    MemoryContextSwitchTo(oldcxt);
}

QualifiedNameGetCreationNamespace()

Oid QualifiedNameGetCreationNamespace	(	List *	names,
		char **	objname_p
	)

Definition at line 2994 of file namespace.c.

References AccessTempTableNamespace(), activeCreationNamespace, activeTempCreationPending, DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, get_namespace_oid(), myTempNamespace, OidIsValid, and recomputeNamespacePath().

Referenced by compute_return_type(), CreateConversionCommand(), CreateFunction(), CreateStatistics(), DefineAggregate(), DefineCollation(), DefineDomain(), DefineEnum(), DefineOpClass(), DefineOperator(), DefineOpFamily(), DefineRange(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), DefineType(), and get_other_operator().

{
    char       *schemaname;
    Oid         namespaceId;

    /* deconstruct the name list */
    DeconstructQualifiedName(names, &schemaname, objname_p);

    if (schemaname)
    {
        /* check for pg_temp alias */
        if (strcmp(schemaname, "pg_temp") == 0)
        {
            /* Initialize temp namespace */
            AccessTempTableNamespace(false);
            return myTempNamespace;
        }
        /* use exact schema given */
        namespaceId = get_namespace_oid(schemaname, false);
        /* we do not check for USAGE rights here! */
    }
    else
    {
        /* use the default creation namespace */
        recomputeNamespacePath();
        if (activeTempCreationPending)
        {
            /* Need to initialize temp namespace */
            AccessTempTableNamespace(true);
            return myTempNamespace;
        }
        namespaceId = activeCreationNamespace;
        if (!OidIsValid(namespaceId))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_SCHEMA),
                     errmsg("no schema has been selected to create in")));
    }

    return namespaceId;
}

RangeVarAdjustRelationPersistence()

void RangeVarAdjustRelationPersistence	(	RangeVar *	newRelation,
		Oid	nspid
	)

Definition at line 641 of file namespace.c.

References ereport, errcode(), errmsg(), ERROR, isAnyTempNamespace(), isTempOrTempToastNamespace(), and RangeVar::relpersistence.

Referenced by DefineCompositeType(), generateSerialExtraStmts(), and RangeVarGetAndCheckCreationNamespace().

{
    switch (newRelation->relpersistence)
    {
        case RELPERSISTENCE_TEMP:
            if (!isTempOrTempToastNamespace(nspid))
            {
                if (isAnyTempNamespace(nspid))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                             errmsg("cannot create relations in temporary schemas of other sessions")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                             errmsg("cannot create temporary relation in non-temporary schema")));
            }
            break;
        case RELPERSISTENCE_PERMANENT:
            if (isTempOrTempToastNamespace(nspid))
                newRelation->relpersistence = RELPERSISTENCE_TEMP;
            else if (isAnyTempNamespace(nspid))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("cannot create relations in temporary schemas of other sessions")));
            break;
        default:
            if (isAnyTempNamespace(nspid))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                         errmsg("only temporary relations may be created in temporary schemas")));
    }
}

RangeVarGetAndCheckCreationNamespace()

Oid RangeVarGetAndCheckCreationNamespace	(	RangeVar *	relation,
		LOCKMODE	lockmode,
		Oid *	existing_relation_id
	)

Definition at line 534 of file namespace.c.

References AccessShareLock, ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, Assert, RangeVar::catalogname, ereport, errcode(), errmsg(), ERROR, get_database_name(), get_namespace_name(), get_rel_relkind(), get_relkind_objtype(), get_relname_relid(), GetUserId(), InvalidOid, IsBootstrapProcessingMode, LockDatabaseObject(), LockRelationOid(), MyDatabaseId, NoLock, OBJECT_SCHEMA, OidIsValid, pg_class_ownercheck(), pg_namespace_aclcheck(), RangeVarAdjustRelationPersistence(), RangeVarGetCreationNamespace(), RangeVar::relname, RangeVar::schemaname, SharedInvalidMessageCounter, UnlockDatabaseObject(), and UnlockRelationOid().

Referenced by AlterTableNamespace(), DefineCompositeType(), DefineRelation(), DefineSequence(), DefineVirtualRelation(), and transformCreateStmt().

{
    uint64      inval_count;
    Oid         relid;
    Oid         oldrelid = InvalidOid;
    Oid         nspid;
    Oid         oldnspid = InvalidOid;
    bool        retry = false;

    /*
     * We check the catalog name and then ignore it.
     */
    if (relation->catalogname)
    {
        if (strcmp(relation->catalogname, get_database_name(MyDatabaseId)) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
                            relation->catalogname, relation->schemaname,
                            relation->relname)));
    }

    /*
     * As in RangeVarGetRelidExtended(), we guard against concurrent DDL
     * operations by tracking whether any invalidation messages are processed
     * while we're doing the name lookups and acquiring locks.  See comments
     * in that function for a more detailed explanation of this logic.
     */
    for (;;)
    {
        AclResult   aclresult;

        inval_count = SharedInvalidMessageCounter;

        /* Look up creation namespace and check for existing relation. */
        nspid = RangeVarGetCreationNamespace(relation);
        Assert(OidIsValid(nspid));
        if (existing_relation_id != NULL)
            relid = get_relname_relid(relation->relname, nspid);
        else
            relid = InvalidOid;

        /*
         * In bootstrap processing mode, we don't bother with permissions or
         * locking.  Permissions might not be working yet, and locking is
         * unnecessary.
         */
        if (IsBootstrapProcessingMode())
            break;

        /* Check namespace permissions. */
        aclresult = pg_namespace_aclcheck(nspid, GetUserId(), ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_SCHEMA,
                           get_namespace_name(nspid));

        if (retry)
        {
            /* If nothing changed, we're done. */
            if (relid == oldrelid && nspid == oldnspid)
                break;
            /* If creation namespace has changed, give up old lock. */
            if (nspid != oldnspid)
                UnlockDatabaseObject(NamespaceRelationId, oldnspid, 0,
                                     AccessShareLock);
            /* If name points to something different, give up old lock. */
            if (relid != oldrelid && OidIsValid(oldrelid) && lockmode != NoLock)
                UnlockRelationOid(oldrelid, lockmode);
        }

        /* Lock namespace. */
        if (nspid != oldnspid)
            LockDatabaseObject(NamespaceRelationId, nspid, 0, AccessShareLock);

        /* Lock relation, if required if and we have permission. */
        if (lockmode != NoLock && OidIsValid(relid))
        {
            if (!pg_class_ownercheck(relid, GetUserId()))
                aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relid)),
                               relation->relname);
            if (relid != oldrelid)
                LockRelationOid(relid, lockmode);
        }

        /* If no invalidation message were processed, we're done! */
        if (inval_count == SharedInvalidMessageCounter)
            break;

        /* Something may have changed, so recheck our work. */
        retry = true;
        oldrelid = relid;
        oldnspid = nspid;
    }

    RangeVarAdjustRelationPersistence(relation, nspid);
    if (existing_relation_id != NULL)
        *existing_relation_id = relid;
    return nspid;
}

RangeVarGetCreationNamespace()

Oid RangeVarGetCreationNamespace

(

const RangeVar *

newRelation

)

Definition at line 449 of file namespace.c.

References AccessTempTableNamespace(), activeCreationNamespace, activeTempCreationPending, RangeVar::catalogname, ereport, errcode(), errmsg(), ERROR, get_database_name(), get_namespace_oid(), MyDatabaseId, myTempNamespace, OidIsValid, recomputeNamespacePath(), RangeVar::relname, RangeVar::relpersistence, and RangeVar::schemaname.

Referenced by ExecCreateTableAs(), generateSerialExtraStmts(), and RangeVarGetAndCheckCreationNamespace().

{
    Oid         namespaceId;

    /*
     * We check the catalog name and then ignore it.
     */
    if (newRelation->catalogname)
    {
        if (strcmp(newRelation->catalogname, get_database_name(MyDatabaseId)) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
                            newRelation->catalogname, newRelation->schemaname,
                            newRelation->relname)));
    }

    if (newRelation->schemaname)
    {
        /* check for pg_temp alias */
        if (strcmp(newRelation->schemaname, "pg_temp") == 0)
        {
            /* Initialize temp namespace */
            AccessTempTableNamespace(false);
            return myTempNamespace;
        }
        /* use exact schema given */
        namespaceId = get_namespace_oid(newRelation->schemaname, false);
        /* we do not check for USAGE rights here! */
    }
    else if (newRelation->relpersistence == RELPERSISTENCE_TEMP)
    {
        /* Initialize temp namespace */
        AccessTempTableNamespace(false);
        return myTempNamespace;
    }
    else
    {
        /* use the default creation namespace */
        recomputeNamespacePath();
        if (activeTempCreationPending)
        {
            /* Need to initialize temp namespace */
            AccessTempTableNamespace(true);
            return myTempNamespace;
        }
        namespaceId = activeCreationNamespace;
        if (!OidIsValid(namespaceId))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_SCHEMA),
                     errmsg("no schema has been selected to create in")));
    }

    /* Note: callers will check for CREATE rights when appropriate */

    return namespaceId;
}

RangeVarGetRelidExtended()

Oid RangeVarGetRelidExtended	(	const RangeVar *	relation,
		LOCKMODE	lockmode,
		uint32	flags,
		RangeVarGetRelidCallback	callback,
		void *	callback_arg
	)

Definition at line 236 of file namespace.c.

References AcceptInvalidationMessages(), Assert, callback(), RangeVar::catalogname, ConditionalLockRelationOid(), DEBUG1, elevel, ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, get_database_name(), get_relname_relid(), InvalidOid, LockRelationOid(), LookupExplicitNamespace(), MyDatabaseId, myTempNamespace, NoLock, OidIsValid, RangeVar::relname, RelnameGetRelid(), RangeVar::relpersistence, RVR_MISSING_OK, RVR_NOWAIT, RVR_SKIP_LOCKED, RangeVar::schemaname, SharedInvalidMessageCounter, and UnlockRelationOid().

Referenced by AlterPolicy(), AlterSequence(), AlterTableLookupRelation(), AlterTableNamespace(), ATExecAttachPartitionIdx(), cluster(), CreatePolicy(), ExecRefreshMatView(), ExecuteTruncate(), expand_vacuum_rel(), LockTableCommand(), ProcessUtilitySlow(), ReindexIndex(), ReindexTable(), RemoveRelations(), rename_policy(), renameatt(), RenameConstraint(), RenameRelation(), RenameRewriteRule(), and renametrig().

{
    uint64      inval_count;
    Oid         relId;
    Oid         oldRelId = InvalidOid;
    bool        retry = false;
    bool        missing_ok = (flags & RVR_MISSING_OK) != 0;

    /* verify that flags do no conflict */
    Assert(!((flags & RVR_NOWAIT) && (flags & RVR_SKIP_LOCKED)));

    /*
     * We check the catalog name and then ignore it.
     */
    if (relation->catalogname)
    {
        if (strcmp(relation->catalogname, get_database_name(MyDatabaseId)) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
                            relation->catalogname, relation->schemaname,
                            relation->relname)));
    }

    /*
     * DDL operations can change the results of a name lookup.  Since all such
     * operations will generate invalidation messages, we keep track of
     * whether any such messages show up while we're performing the operation,
     * and retry until either (1) no more invalidation messages show up or (2)
     * the answer doesn't change.
     *
     * But if lockmode = NoLock, then we assume that either the caller is OK
     * with the answer changing under them, or that they already hold some
     * appropriate lock, and therefore return the first answer we get without
     * checking for invalidation messages.  Also, if the requested lock is
     * already held, LockRelationOid will not AcceptInvalidationMessages, so
     * we may fail to notice a change.  We could protect against that case by
     * calling AcceptInvalidationMessages() before beginning this loop, but
     * that would add a significant amount overhead, so for now we don't.
     */
    for (;;)
    {
        /*
         * Remember this value, so that, after looking up the relation name
         * and locking its OID, we can check whether any invalidation messages
         * have been processed that might require a do-over.
         */
        inval_count = SharedInvalidMessageCounter;

        /*
         * Some non-default relpersistence value may have been specified.  The
         * parser never generates such a RangeVar in simple DML, but it can
         * happen in contexts such as "CREATE TEMP TABLE foo (f1 int PRIMARY
         * KEY)".  Such a command will generate an added CREATE INDEX
         * operation, which must be careful to find the temp table, even when
         * pg_temp is not first in the search path.
         */
        if (relation->relpersistence == RELPERSISTENCE_TEMP)
        {
            if (!OidIsValid(myTempNamespace))
                relId = InvalidOid; /* this probably can't happen? */
            else
            {
                if (relation->schemaname)
                {
                    Oid         namespaceId;

                    namespaceId = LookupExplicitNamespace(relation->schemaname, missing_ok);

                    /*
                     * For missing_ok, allow a non-existent schema name to
                     * return InvalidOid.
                     */
                    if (namespaceId != myTempNamespace)
                        ereport(ERROR,
                                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
                                 errmsg("temporary tables cannot specify a schema name")));
                }

                relId = get_relname_relid(relation->relname, myTempNamespace);
            }
        }
        else if (relation->schemaname)
        {
            Oid         namespaceId;

            /* use exact schema given */
            namespaceId = LookupExplicitNamespace(relation->schemaname, missing_ok);
            if (missing_