namespace.h File Reference

#include "nodes/primnodes.h"
#include "storage/lock.h"

Include dependency graph for namespace.h:

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

Go to the source code of this file.

Data Structures
struct	_FuncCandidateList
struct	OverrideSearchPath

Macros
#define	RangeVarGetRelid(relation, lockmode, missing_ok)

Typedefs
typedef struct _FuncCandidateList *	FuncCandidateList
typedef enum TempNamespaceStatus	TempNamespaceStatus
typedef struct OverrideSearchPath	OverrideSearchPath
typedef enum RVROption	RVROption
typedef void(*	RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId, Oid oldRelId, void *callback_arg)

Enumerations
enum	TempNamespaceStatus { TEMP_NAMESPACE_NOT_TEMP , TEMP_NAMESPACE_IDLE , TEMP_NAMESPACE_IN_USE }
enum	RVROption { RVR_MISSING_OK = 1 << 0 , RVR_NOWAIT = 1 << 1 , RVR_SKIP_LOCKED = 1 << 2 }

Functions
Oid	RangeVarGetRelidExtended (const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Oid	RangeVarGetCreationNamespace (const RangeVar *newRelation)
Oid	RangeVarGetAndCheckCreationNamespace (RangeVar *newRelation, 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 include_out_arguments, 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)
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	get_namespace_oid (const char *nspname, bool missing_ok)
Oid	LookupCreationNamespace (const char *nspname)
void	CheckSetNamespace (Oid oldNspOid, Oid nspOid)
Oid	QualifiedNameGetCreationNamespace (List *names, char **objname_p)
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)
void	ResetTempTableNamespace (void)
OverrideSearchPath *	GetOverrideSearchPath (MemoryContext context)
OverrideSearchPath *	CopyOverrideSearchPath (OverrideSearchPath *path)
bool	OverrideSearchPathMatchesCurrent (OverrideSearchPath *path)
void	PushOverrideSearchPath (OverrideSearchPath *newpath)
void	PopOverrideSearchPath (void)
Oid	get_collation_oid (List *collname, bool missing_ok)
Oid	get_conversion_oid (List *conname, bool missing_ok)
Oid	FindDefaultConversionProc (int32 for_encoding, int32 to_encoding)
void	InitializeSearchPath (void)
void	AtEOXact_Namespace (bool isCommit, bool parallel)
void	AtEOSubXact_Namespace (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
List *	fetch_search_path (bool includeImplicit)
int	fetch_search_path_array (Oid *sarray, int sarray_len)

Variables
char *	namespace_search_path

Macro Definition Documentation

RangeVarGetRelid

#define RangeVarGetRelid	(		relation,
			lockmode,
			missing_ok
	)

Value:

    RangeVarGetRelidExtended(relation, lockmode, \
                             (missing_ok) ? RVR_MISSING_OK : 0, NULL, NULL)

Definition at line 79 of file namespace.h.

Typedef Documentation

FuncCandidateList

typedef struct _FuncCandidateList * FuncCandidateList

OverrideSearchPath

typedef struct OverrideSearchPath OverrideSearchPath

RangeVarGetRelidCallback

typedef void(* RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId, Oid oldRelId, void *callback_arg)

Definition at line 76 of file namespace.h.

RVROption

typedef enum RVROption RVROption

TempNamespaceStatus

typedef enum TempNamespaceStatus TempNamespaceStatus

Enumeration Type Documentation

RVROption

enum RVROption

Enumerator
RVR_MISSING_OK
RVR_NOWAIT
RVR_SKIP_LOCKED

Definition at line 69 of file namespace.h.

{
    RVR_MISSING_OK = 1 << 0,    /* don't error if relation doesn't exist */
    RVR_NOWAIT = 1 << 1,        /* error if relation cannot be locked */
    RVR_SKIP_LOCKED = 1 << 2    /* skip if relation cannot be locked */
} RVROption;

TempNamespaceStatus

enum TempNamespaceStatus

Enumerator
TEMP_NAMESPACE_NOT_TEMP
TEMP_NAMESPACE_IDLE
TEMP_NAMESPACE_IN_USE

Definition at line 44 of file namespace.h.

{
    TEMP_NAMESPACE_NOT_TEMP,    /* nonexistent, or non-temp namespace */
    TEMP_NAMESPACE_IDLE,        /* exists, belongs to no active session */
    TEMP_NAMESPACE_IN_USE       /* belongs to some active session */
} TempNamespaceStatus;

Function Documentation

AtEOSubXact_Namespace()

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

Definition at line 4177 of file namespace.c.

{
    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.
         */
    }
}

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_Namespace()

void AtEOXact_Namespace	(	bool	isCommit,
		bool	parallel
	)

Definition at line 4109 of file namespace.c.

{
    /*
     * 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++;
    }
}

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

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

CheckSetNamespace()

void CheckSetNamespace	(	Oid	oldNspOid,
		Oid	nspOid
	)

Definition at line 3012 of file namespace.c.

{
    /* 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")));
}

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

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

checkTempNamespaceStatus()

TempNamespaceStatus checkTempNamespaceStatus

(

Oid

namespaceId

)

Definition at line 3282 of file namespace.c.

{
    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;
}

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().

CollationGetCollid()

Oid CollationGetCollid

(

const char *

collname

)

Definition at line 2059 of file namespace.c.

{
    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;
}

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

Referenced by CollationIsVisible().

CollationIsVisible()

bool CollationIsVisible

(

Oid

collid

)

Definition at line 2093 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

ConversionGetConid()

Oid ConversionGetConid

(

const char *

conname

)

Definition at line 2144 of file namespace.c.

{
    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;
}

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

Referenced by ConversionIsVisible().

ConversionIsVisible()

bool ConversionIsVisible

(

Oid

conid

)

Definition at line 2176 of file namespace.c.

{
    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;
}

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

Referenced by getObjectDescription(), and pg_conversion_is_visible().

CopyOverrideSearchPath()

OverrideSearchPath* CopyOverrideSearchPath

(

OverrideSearchPath *

path

)

Definition at line 3442 of file namespace.c.

{
    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;
}

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

Referenced by CopyCachedPlan().

DeconstructQualifiedName()

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

Definition at line 2854 of file namespace.c.

{
    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;
}

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().

fetch_search_path()

List* fetch_search_path

(

bool

includeImplicit

)

Definition at line 4428 of file namespace.c.

{
    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;
}

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

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

fetch_search_path_array()

int fetch_search_path_array	(	Oid *	sarray,
		int	sarray_len
	)

Definition at line 4468 of file namespace.c.

{
    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;
}

References activeSearchPath, lfirst_oid, myTempNamespace, and recomputeNamespacePath().

Referenced by make_oper_cache_key().

FindDefaultConversionProc()

Oid FindDefaultConversionProc	(	int32	for_encoding,
		int32	to_encoding
	)

Definition at line 3755 of file namespace.c.

{
    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;
}

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

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

FuncnameGetCandidates()

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

Definition at line 950 of file namespace.c.

{
    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);
        Oid        *proargtypes = procform->proargtypes.values;
        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 we are asked to match to OUT arguments, then use the
         * proallargtypes array (which includes those); otherwise use
         * proargtypes (which doesn't).  Of course, if proallargtypes is null,
         * we always use proargtypes.
         */
        if (include_out_arguments)
        {
            Datum       proallargtypes;
            bool        isNull;
 
            proallargtypes = SysCacheGetAttr(PROCNAMEARGSNSP, proctup,
                                             Anum_pg_proc_proallargtypes,
                                             &isNull);
            if (!isNull)
            {
                ArrayType  *arr = DatumGetArrayTypeP(proallargtypes);
 
                pronargs = ARR_DIMS(arr)[0];
                if (ARR_NDIM(arr) != 1 ||
                    pronargs < 0 ||
                    ARR_HASNULL(arr) ||
                    ARR_ELEMTYPE(arr) != OIDOID)
                    elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls");
                Assert(pronargs >= procform->pronargs);
                proargtypes = (Oid *) ARR_DATA_PTR(arr);
            }
        }
 
        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,
                                include_out_arguments, pronargs,
                                &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->nominalnargs = pronargs;
        newResult->nargs = effective_nargs;
        newResult->argnumbers = argnumbers;
        if (argnumbers)
        {
            /* Re-order the argument types into call's logical order */
            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, proargtypes, 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;
}

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

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

FunctionIsVisible()

bool FunctionIsVisible

(

Oid

funcid

)

Definition at line 1458 of file namespace.c.

{
    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, 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;
}

References activeSearchPath, _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().

get_collation_oid()

Oid get_collation_oid	(	List *	collname,
		bool	missing_ok
	)

Definition at line 3646 of file namespace.c.

{
    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;
}

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

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

get_conversion_oid()

Oid get_conversion_oid	(	List *	conname,
		bool	missing_ok
	)

Definition at line 3700 of file namespace.c.

{
    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;
}

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

Referenced by get_object_address().

get_namespace_oid()

Oid get_namespace_oid	(	const char *	nspname,
		bool	missing_ok
	)

Definition at line 3088 of file namespace.c.

{
    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;
}

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_publication_schema(), get_object_address_unqualified(), InitTempTableNamespace(), LookupCreationNamespace(), LookupExplicitNamespace(), LookupNamespaceNoError(), objectNamesToOids(), ObjectsInPublicationToOids(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), recomputeNamespacePath(), regnamespacein(), ReindexMultipleTables(), RenameSchema(), SetDefaultACLsInSchemas(), and to_regnamespace().

get_statistics_object_oid()

Oid get_statistics_object_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2223 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

get_ts_config_oid()

Oid get_ts_config_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2724 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

get_ts_dict_oid()

Oid get_ts_dict_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2471 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

get_ts_parser_oid()

Oid get_ts_parser_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2345 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

get_ts_template_oid()

Oid get_ts_template_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2598 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

GetOverrideSearchPath()

OverrideSearchPath* GetOverrideSearchPath

(

MemoryContext

context

)

Definition at line 3405 of file namespace.c.

{
    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;
}

References activeCreationNamespace, activePathGeneration, activeSearchPath, 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().

GetTempNamespaceBackendId()

int GetTempNamespaceBackendId

(

Oid

namespaceId

)

Definition at line 3319 of file namespace.c.

{
    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;
}

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

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

GetTempNamespaceState()

void GetTempNamespaceState	(	Oid *	tempNamespaceId,
		Oid *	tempToastNamespaceId
	)

Definition at line 3358 of file namespace.c.

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

References myTempNamespace, and myTempToastNamespace.

Referenced by InitializeParallelDSM().

GetTempToastNamespace()

Oid GetTempToastNamespace

(

void

)

Definition at line 3344 of file namespace.c.

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

References Assert(), myTempToastNamespace, and OidIsValid.

Referenced by create_toast_table().

InitializeSearchPath()

void InitializeSearchPath

(

void

)

Definition at line 4369 of file namespace.c.

{
    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;
    }
}

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

Referenced by InitPostgres().

isAnyTempNamespace()

bool isAnyTempNamespace

(

Oid

namespaceId

)

Definition at line 3240 of file namespace.c.

{
    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;
}

References get_namespace_name(), and pfree().

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

isOtherTempNamespace()

bool isOtherTempNamespace

(

Oid

namespaceId

)

Definition at line 3263 of file namespace.c.

{
    /* 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);
}

References isAnyTempNamespace(), and isTempOrTempToastNamespace().

Referenced by pg_is_other_temp_schema().

isTempNamespace()

bool isTempNamespace

(

Oid

namespaceId

)

Definition at line 3202 of file namespace.c.

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

References myTempNamespace, and OidIsValid.

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

isTempOrTempToastNamespace()

bool isTempOrTempToastNamespace

(

Oid

namespaceId

)

Definition at line 3226 of file namespace.c.

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

References myTempNamespace, myTempToastNamespace, and OidIsValid.

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

isTempToastNamespace()

bool isTempToastNamespace

(

Oid

namespaceId

)

Definition at line 3214 of file namespace.c.

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

References myTempToastNamespace, and OidIsValid.

Referenced by IsToastNamespace().

LookupCreationNamespace()

Oid LookupCreationNamespace

(

const char *

nspname

)

Definition at line 2981 of file namespace.c.

{
    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;
}

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().

LookupExplicitNamespace()

Oid LookupExplicitNamespace	(	const char *	nspname,
		bool	missing_ok
	)

Definition at line 2938 of file namespace.c.

{
    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;
}

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().

LookupNamespaceNoError()

Oid LookupNamespaceNoError

(

const char *

nspname

)

Definition at line 2908 of file namespace.c.

{
    /* 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);
}

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

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

makeRangeVarFromNameList()

RangeVar* makeRangeVarFromNameList

(

List *

names

)

Definition at line 3107 of file namespace.c.

{
    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;
}

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_internal(), bt_page_stats_internal(), 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().

NameListToQuotedString()

char* NameListToQuotedString

(

List *

names

)

Definition at line 3181 of file namespace.c.

{
    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;
}

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

NameListToString()

char* NameListToString

(

List *

names

)

Definition at line 3147 of file namespace.c.

{
    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;
}

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(), CreateTriggerFiringOn(), DeconstructQualifiedName(), defGetString(), DefineOperator(), DefineType(), does_not_exist_skipping(), dropOperators(), dropProcedures(), ExpandColumnRefStar(), findRangeSubOpclass(), findTypeAnalyzeFunction(), findTypeInputFunction(), findTypeOutputFunction(), findTypeReceiveFunction(), findTypeSendFunction(), findTypeSubscriptingFunction(), 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().

OpclassIsVisible()

bool OpclassIsVisible

(

Oid

opcid

)

Definition at line 1878 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

OpclassnameGetOpcid()

Oid OpclassnameGetOpcid	(	Oid	amid,
		const char *	opcname
	)

Definition at line 1845 of file namespace.c.

{
    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;
}

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

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

OperatorIsVisible()

bool OperatorIsVisible

(

Oid

oprid

)

Definition at line 1792 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

OpernameGetCandidates()

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

Definition at line 1631 of file namespace.c.

{
    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->nominalnargs = 2;
        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;
}

References activeSearchPath, _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::nominalnargs, _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().

OpernameGetOprid()

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

Definition at line 1528 of file namespace.c.

{
    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;
}

References activeSearchPath, 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().

OpfamilyIsVisible()

bool OpfamilyIsVisible

(

Oid

opfid

)

Definition at line 1961 of file namespace.c.

{
    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;
}

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

Referenced by getOpFamilyDescription(), and pg_opfamily_is_visible().

OpfamilynameGetOpfid()

Oid OpfamilynameGetOpfid	(	Oid	amid,
		const char *	opfname
	)

Definition at line 1928 of file namespace.c.

{
    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;
}

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

Referenced by OpFamilyCacheLookup(), and OpfamilyIsVisible().

OverrideSearchPathMatchesCurrent()

bool OverrideSearchPathMatchesCurrent

(

OverrideSearchPath *

path

)

Definition at line 3464 of file namespace.c.

{
    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;
}

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

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

PopOverrideSearchPath()

void PopOverrideSearchPath

(

void

)

Definition at line 3602 of file namespace.c.

{
    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++;
}

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

Referenced by CreateSchemaCommand().

PushOverrideSearchPath()

void PushOverrideSearchPath

(

OverrideSearchPath *

newpath

)

Definition at line 3535 of file namespace.c.

{
    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);
}

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

Referenced by CreateSchemaCommand().

QualifiedNameGetCreationNamespace()

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

Definition at line 3040 of file namespace.c.

{
    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;
}

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().

RangeVarAdjustRelationPersistence()

void RangeVarAdjustRelationPersistence	(	RangeVar *	newRelation,
		Oid	nspid
	)

Definition at line 642 of file namespace.c.

{
    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")));
    }
}

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

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

RangeVarGetAndCheckCreationNamespace()

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

Definition at line 535 of file namespace.c.

{
    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;
}

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().

RangeVarGetCreationNamespace()

Oid RangeVarGetCreationNamespace

(

const RangeVar *

newRelation

)

Definition at line 450 of file namespace.c.

{
    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;
}

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 CreateTableAsRelExists(), generateSerialExtraStmts(), and RangeVarGetAndCheckCreationNamespace().

RangeVarGetRelidExtended()

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

Definition at line 237 of file namespace.c.

{
    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_ok && !OidIsValid(namespaceId))
                relId = InvalidOid;
            else
                relId = get_relname_relid(relation->relname, namespaceId);
        }
        else
        {
            /* search the namespace path */
            relId = RelnameGetRelid(relation->relname);
        }
 
        /*
         * Invoke caller-supplied callback, if any.
         *
         * This callback is a good place to check permissions: we haven't
         * taken the table lock yet (and it's really best to check permissions
         * before locking anything!), but we've gotten far enough to know what
         * OID we think we should lock.  Of course, concurrent DDL might
         * change things while we're waiting for the lock, but in that case
         * the callback will be invoked again for the new OID.
         */
        if (callback)
            callback(relation, relId, oldRelId, callback_arg);
 
        /*
         * If no lock requested, we assume the caller knows what they're
         * doing.  They should have already acquired a heavyweight lock on
         * this relation earlier in the processing of this same statement, so
         * it wouldn't be appropriate to AcceptInvalidationMessages() here, as
         * that might pull the rug out from under them.
         */
        if (lockmode == NoLock)
            break;
 
        /*
         * If, upon retry, we get back the same OID we did last time, then the
         * invalidation messages we processed did not change the final answer.
         * So we're done.
         *
         * If we got a different OID, we've locked the relation that used to
         * have this name rather than the one that does now.  So release the
         * lock.
         */
        if (retry)
        {
            if (relId == oldRelId)
                break;
            if (OidIsValid(oldRelId))
                UnlockRelationOid(oldRelId, lockmode);
        }
 
        /*
         * Lock relation.  This will also accept any pending invalidation
         * messages.  If we got back InvalidOid, indicating not found, then
         * there's nothing to lock, but we accept invalidation messages
         * anyway, to flush any negative catcache entries that may be
         * lingering.
         */
        if (!OidIsValid(relId))
            AcceptInvalidationMessages();
        else if (!(flags & (RVR_NOWAIT | RVR_SKIP_LOCKED)))
            LockRelationOid(relId, lockmode);
        else if (!ConditionalLockRelationOid(relId, lockmode))
        {
            int         elevel = (flags & RVR_SKIP_LOCKED) ? DEBUG1 : ERROR;
 
            if (relation->schemaname)
                ereport(elevel,
                        (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                         errmsg("could not obtain lock on relation \"%s.%s\"",
                                relation->schemaname, relation->relname)));
            else
                ereport(elevel,
                        (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                         errmsg("could not obtain lock on relation \"%s\"",
                                relation->relname)));
 
            return InvalidOid;
        }
 
        /*
         * If no invalidation message were processed, we're done!
         */
        if (inval_count == SharedInvalidMessageCounter)
            break;
 
        /*
         * Something may have changed.  Let's repeat the name lookup, to make
         * sure this name still references the same relation it did
         * previously.
         */
        retry = true;
        oldRelId = relId;
    }
 
    if (!OidIsValid(relId))
    {
        int         elevel = missing_ok ? DEBUG1 : ERROR;
 
        if (relation->schemaname)
            ereport(elevel,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("relation \"%s.%s\" does not exist",
                            relation->schemaname, relation->relname)));
        else
            ereport(elevel,
                    (errcode(ERRCODE_UNDEFINED_TABLE),
                     errmsg("relation \"%s\" does not exist",
                            relation->relname)));
    }
    return relId;
}

References AcceptInvalidationMessages(), Assert(), callback(), RangeVar::catalogname, ConditionalLockRelationOid(), DEBUG1, 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().

RelationIsVisible()

bool RelationIsVisible

(

Oid

relid

)

Definition at line 709 of file namespace.c.

{
    HeapTuple   reltup;
    Form_pg_class relform;
    Oid         relnamespace;
    bool        visible;
 
    reltup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(reltup))
        elog(ERROR, "cache lookup failed for relation %u", relid);
    relform = (Form_pg_class) GETSTRUCT(reltup);
 
    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.
     */
    relnamespace = relform->relnamespace;
    if (relnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, relnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another relation of the same name earlier in the path. So
         * we must do a slow check for conflicting relations.
         */
        char       *relname = NameStr(relform->relname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == relnamespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (OidIsValid(get_relname_relid(relname, namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(reltup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, get_relname_relid(), GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), NameStr, ObjectIdGetDatum, OidIsValid, recomputeNamespacePath(), ReleaseSysCache(), relname, RELOID, and SearchSysCache1().

Referenced by generate_relation_name(), getRelationDescription(), pg_table_is_visible(), and regclassout().

RelnameGetRelid()

Oid RelnameGetRelid

(

const char *

relname

)

Definition at line 681 of file namespace.c.

{
    Oid         relid;
    ListCell   *l;
 
    recomputeNamespacePath();
 
    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);
 
        relid = get_relname_relid(relname, namespaceId);
        if (OidIsValid(relid))
            return relid;
    }
 
    /* Not found in path */
    return InvalidOid;
}

References activeSearchPath, get_relname_relid(), InvalidOid, lfirst_oid, OidIsValid, recomputeNamespacePath(), and relname.

Referenced by plpgsql_parse_cwordtype(), plpgsql_parse_wordrowtype(), and RangeVarGetRelidExtended().

ResetTempTableNamespace()

void ResetTempTableNamespace

(

void

)

Definition at line 4306 of file namespace.c.

{
    if (OidIsValid(myTempNamespace))
        RemoveTempRelations(myTempNamespace);
}

References myTempNamespace, OidIsValid, and RemoveTempRelations().

Referenced by DiscardAll(), and DiscardCommand().

SetTempNamespaceState()

void SetTempNamespaceState	(	Oid	tempNamespaceId,
		Oid	tempToastNamespaceId
	)

Definition at line 3374 of file namespace.c.

{
    /* Worker should not have created its own namespaces ... */
    Assert(myTempNamespace == InvalidOid);
    Assert(myTempToastNamespace == InvalidOid);
    Assert(myTempNamespaceSubID == InvalidSubTransactionId);
 
    /* Assign same namespace OIDs that leader has */
    myTempNamespace = tempNamespaceId;
    myTempToastNamespace = tempToastNamespaceId;
 
    /*
     * It's fine to leave myTempNamespaceSubID == InvalidSubTransactionId.
     * Even if the namespace is new so far as the leader is concerned, it's
     * not new to the worker, and we certainly wouldn't want the worker trying
     * to destroy it.
     */
 
    baseSearchPathValid = false;    /* may need to rebuild list */
}

References Assert(), baseSearchPathValid, InvalidOid, InvalidSubTransactionId, myTempNamespace, myTempNamespaceSubID, and myTempToastNamespace.

Referenced by ParallelWorkerMain().

StatisticsObjIsVisible()

bool StatisticsObjIsVisible

(

Oid

relid

)

Definition at line 2280 of file namespace.c.

{
    HeapTuple   stxtup;
    Form_pg_statistic_ext stxform;
    Oid         stxnamespace;
    bool        visible;
 
    stxtup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(stxtup))
        elog(ERROR, "cache lookup failed for statistics object %u", relid);
    stxform = (Form_pg_statistic_ext) GETSTRUCT(stxtup);
 
    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.
     */
    stxnamespace = stxform->stxnamespace;
    if (stxnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, stxnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another statistics object of the same name earlier in the
         * path. So we must do a slow check for conflicting objects.
         */
        char       *stxname = NameStr(stxform->stxname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == stxnamespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (SearchSysCacheExists2(STATEXTNAMENSP,
                                      PointerGetDatum(stxname),
                                      ObjectIdGetDatum(namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(stxtup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), NameStr, ObjectIdGetDatum, PointerGetDatum, recomputeNamespacePath(), ReleaseSysCache(), SearchSysCache1(), SearchSysCacheExists2, STATEXTNAMENSP, and STATEXTOID.

Referenced by getObjectDescription(), and pg_statistics_obj_is_visible().

TSConfigIsVisible()

bool TSConfigIsVisible

(

Oid

cfgid

)

Definition at line 2782 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_config form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for text search configuration %u",
             cfgid);
    form = (Form_pg_ts_config) GETSTRUCT(tup);
 
    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.
     */
    namespace = form->cfgnamespace;
    if (namespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, namespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another configuration of the same name earlier in the
         * path. So we must do a slow check for conflicting configurations.
         */
        char       *name = NameStr(form->cfgname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */
 
            if (namespaceId == namespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (SearchSysCacheExists2(TSCONFIGNAMENSP,
                                      PointerGetDatum(name),
                                      ObjectIdGetDatum(namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(tup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), myTempNamespace, name, NameStr, ObjectIdGetDatum, PointerGetDatum, recomputeNamespacePath(), ReleaseSysCache(), SearchSysCache1(), SearchSysCacheExists2, TSCONFIGNAMENSP, and TSCONFIGOID.

Referenced by getObjectDescription(), pg_ts_config_is_visible(), and regconfigout().

TSDictionaryIsVisible()

bool TSDictionaryIsVisible

(

Oid

dictId

)

Definition at line 2529 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_dict form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for text search dictionary %u",
             dictId);
    form = (Form_pg_ts_dict) GETSTRUCT(tup);
 
    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.
     */
    namespace = form->dictnamespace;
    if (namespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, namespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another dictionary of the same name earlier in the path.
         * So we must do a slow check for conflicting dictionaries.
         */
        char       *name = NameStr(form->dictname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */
 
            if (namespaceId == namespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (SearchSysCacheExists2(TSDICTNAMENSP,
                                      PointerGetDatum(name),
                                      ObjectIdGetDatum(namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(tup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), myTempNamespace, name, NameStr, ObjectIdGetDatum, PointerGetDatum, recomputeNamespacePath(), ReleaseSysCache(), SearchSysCache1(), SearchSysCacheExists2, TSDICTNAMENSP, and TSDICTOID.

Referenced by getObjectDescription(), pg_ts_dict_is_visible(), and regdictionaryout().

TSParserIsVisible()

bool TSParserIsVisible

(

Oid

prsId

)

Definition at line 2403 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_parser form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(prsId));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for text search parser %u", prsId);
    form = (Form_pg_ts_parser) GETSTRUCT(tup);
 
    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.
     */
    namespace = form->prsnamespace;
    if (namespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, namespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another parser of the same name earlier in the path. So
         * we must do a slow check for conflicting parsers.
         */
        char       *name = NameStr(form->prsname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */
 
            if (namespaceId == namespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (SearchSysCacheExists2(TSPARSERNAMENSP,
                                      PointerGetDatum(name),
                                      ObjectIdGetDatum(namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(tup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), myTempNamespace, name, NameStr, ObjectIdGetDatum, PointerGetDatum, recomputeNamespacePath(), ReleaseSysCache(), SearchSysCache1(), SearchSysCacheExists2, TSPARSERNAMENSP, and TSPARSEROID.

Referenced by getObjectDescription(), and pg_ts_parser_is_visible().

TSTemplateIsVisible()

bool TSTemplateIsVisible

(

Oid

tmplId

)

Definition at line 2656 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_template form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(tmplId));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for text search template %u", tmplId);
    form = (Form_pg_ts_template) GETSTRUCT(tup);
 
    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.
     */
    namespace = form->tmplnamespace;
    if (namespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, namespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another template of the same name earlier in the path. So
         * we must do a slow check for conflicting templates.
         */
        char       *name = NameStr(form->tmplname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == myTempNamespace)
                continue;       /* do not look in temp namespace */
 
            if (namespaceId == namespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (SearchSysCacheExists2(TSTEMPLATENAMENSP,
                                      PointerGetDatum(name),
                                      ObjectIdGetDatum(namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(tup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), myTempNamespace, name, NameStr, ObjectIdGetDatum, PointerGetDatum, recomputeNamespacePath(), ReleaseSysCache(), SearchSysCache1(), SearchSysCacheExists2, TSTEMPLATENAMENSP, and TSTEMPLATEOID.

Referenced by getObjectDescription(), and pg_ts_template_is_visible().

TypeIsVisible()

bool TypeIsVisible

(

Oid

typid

)

Definition at line 817 of file namespace.c.

{
    HeapTuple   typtup;
    Form_pg_type typform;
    Oid         typnamespace;
    bool        visible;
 
    typtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(typtup))
        elog(ERROR, "cache lookup failed for type %u", typid);
    typform = (Form_pg_type) GETSTRUCT(typtup);
 
    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.
     */
    typnamespace = typform->typnamespace;
    if (typnamespace != PG_CATALOG_NAMESPACE &&
        !list_member_oid(activeSearchPath, typnamespace))
        visible = false;
    else
    {
        /*
         * If it is in the path, it might still not be visible; it could be
         * hidden by another type of the same name earlier in the path. So we
         * must do a slow check for conflicting types.
         */
        char       *typname = NameStr(typform->typname);
        ListCell   *l;
 
        visible = false;
        foreach(l, activeSearchPath)
        {
            Oid         namespaceId = lfirst_oid(l);
 
            if (namespaceId == typnamespace)
            {
                /* Found it first in path */
                visible = true;
                break;
            }
            if (SearchSysCacheExists2(TYPENAMENSP,
                                      PointerGetDatum(typname),
                                      ObjectIdGetDatum(namespaceId)))
            {
                /* Found something else first in path */
                break;
            }
        }
    }
 
    ReleaseSysCache(typtup);
 
    return visible;
}

References activeSearchPath, elog, ERROR, GETSTRUCT, HeapTupleIsValid, lfirst_oid, list_member_oid(), NameStr, ObjectIdGetDatum, PointerGetDatum, recomputeNamespacePath(), ReleaseSysCache(), SearchSysCache1(), SearchSysCacheExists2, TYPENAMENSP, TYPEOID, and typname.

Referenced by format_type_extended(), and pg_type_is_visible().

TypenameGetTypid()

Oid TypenameGetTypid

(

const char *

typname

)

Definition at line 772 of file namespace.c.

{
    return TypenameGetTypidExtended(typname, true);
}

References TypenameGetTypidExtended(), and typname.

TypenameGetTypidExtended()

Oid TypenameGetTypidExtended	(	const char *	typname,
		bool	temp_ok
	)

Definition at line 785 of file namespace.c.

{
    Oid         typid;
    ListCell   *l;
 
    recomputeNamespacePath();
 
    foreach(l, activeSearchPath)
    {
        Oid         namespaceId = lfirst_oid(l);
 
        if (!temp_ok && namespaceId == myTempNamespace)
            continue;           /* do not look in temp namespace */
 
        typid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
                                PointerGetDatum(typname),
                                ObjectIdGetDatum(namespaceId));
        if (OidIsValid(typid))
            return typid;
    }
 
    /* Not found in path */
    return InvalidOid;
}

References activeSearchPath, GetSysCacheOid2, InvalidOid, lfirst_oid, myTempNamespace, ObjectIdGetDatum, OidIsValid, PointerGetDatum, recomputeNamespacePath(), TYPENAMENSP, and typname.

Referenced by LookupTypeNameExtended(), and TypenameGetTypid().

Variable Documentation

namespace_search_path

char* namespace_search_path

extern

Definition at line 198 of file namespace.c.

Referenced by recomputeNamespacePath().