namespace.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/parallel.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "catalog/dependency.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_statistic_ext.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "common/hashfn_unstable.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "storage/ipc.h"
#include "storage/lmgr.h"
#include "storage/procarray.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/guc_hooks.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/varlena.h"
#include "lib/simplehash.h"

Include dependency graph for namespace.c:

Go to the source code of this file.

Data Structures
struct	SearchPathCacheKey
struct	SearchPathCacheEntry

Macros
#define	SH_PREFIX   nsphash
#define	SH_ELEMENT_TYPE   SearchPathCacheEntry
#define	SH_KEY_TYPE   SearchPathCacheKey
#define	SH_KEY   key
#define	SH_HASH_KEY(tb, key)   spcachekey_hash(key)
#define	SH_EQUAL(tb, a, b)   spcachekey_equal(a, b)
#define	SH_SCOPE   static inline
#define	SH_DECLARE
#define	SH_DEFINE
#define	SPCACHE_RESET_THRESHOLD   256
#define	SPACE_PER_OP

Typedefs
typedef struct SearchPathCacheKey	SearchPathCacheKey
typedef struct SearchPathCacheEntry	SearchPathCacheEntry

Functions
static bool	RelationIsVisibleExt (Oid relid, bool *is_missing)
static bool	TypeIsVisibleExt (Oid typid, bool *is_missing)
static bool	FunctionIsVisibleExt (Oid funcid, bool *is_missing)
static bool	OperatorIsVisibleExt (Oid oprid, bool *is_missing)
static bool	OpclassIsVisibleExt (Oid opcid, bool *is_missing)
static bool	OpfamilyIsVisibleExt (Oid opfid, bool *is_missing)
static bool	CollationIsVisibleExt (Oid collid, bool *is_missing)
static bool	ConversionIsVisibleExt (Oid conid, bool *is_missing)
static bool	StatisticsObjIsVisibleExt (Oid stxid, bool *is_missing)
static bool	TSParserIsVisibleExt (Oid prsId, bool *is_missing)
static bool	TSDictionaryIsVisibleExt (Oid dictId, bool *is_missing)
static bool	TSTemplateIsVisibleExt (Oid tmplId, bool *is_missing)
static bool	TSConfigIsVisibleExt (Oid cfgid, bool *is_missing)
static void	recomputeNamespacePath (void)
static void	AccessTempTableNamespace (bool force)
static void	InitTempTableNamespace (void)
static void	RemoveTempRelations (Oid tempNamespaceId)
static void	RemoveTempRelationsCallback (int code, Datum arg)
static void	InvalidationCallback (Datum arg, int cacheid, uint32 hashvalue)
static bool	MatchNamedCall (HeapTuple proctup, int nargs, List *argnames, bool include_out_arguments, int pronargs, int **argnumbers)
static uint32	spcachekey_hash (SearchPathCacheKey key)
static bool	spcachekey_equal (SearchPathCacheKey a, SearchPathCacheKey b)
static void	spcache_init (void)
static SearchPathCacheEntry *	spcache_lookup (const char *searchPath, Oid roleid)
static SearchPathCacheEntry *	spcache_insert (const char *searchPath, Oid roleid)
Oid	RangeVarGetRelidExtended (const RangeVar *relation, LOCKMODE lockmode, uint32 flags, RangeVarGetRelidCallback callback, void *callback_arg)
Oid	RangeVarGetCreationNamespace (const RangeVar *newRelation)
Oid	RangeVarGetAndCheckCreationNamespace (RangeVar *relation, LOCKMODE lockmode, Oid *existing_relation_id)
void	RangeVarAdjustRelationPersistence (RangeVar *newRelation, Oid nspid)
Oid	RelnameGetRelid (const char *relname)
bool	RelationIsVisible (Oid relid)
Oid	TypenameGetTypid (const char *typname)
Oid	TypenameGetTypidExtended (const char *typname, bool temp_ok)
bool	TypeIsVisible (Oid typid)
FuncCandidateList	FuncnameGetCandidates (List *names, int nargs, List *argnames, bool expand_variadic, bool expand_defaults, bool 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)
static Oid	lookup_collation (const char *collname, Oid collnamespace, int32 encoding)
Oid	CollationGetCollid (const char *collname)
bool	CollationIsVisible (Oid collid)
Oid	ConversionGetConid (const char *conname)
bool	ConversionIsVisible (Oid conid)
Oid	get_statistics_object_oid (List *names, bool missing_ok)
bool	StatisticsObjIsVisible (Oid stxid)
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 (const List *names, char **nspname_p, char **objname_p)
Oid	LookupNamespaceNoError (const char *nspname)
Oid	LookupExplicitNamespace (const char *nspname, bool missing_ok)
Oid	LookupCreationNamespace (const char *nspname)
void	CheckSetNamespace (Oid oldNspOid, Oid nspOid)
Oid	QualifiedNameGetCreationNamespace (const List *names, char **objname_p)
Oid	get_namespace_oid (const char *nspname, bool missing_ok)
RangeVar *	makeRangeVarFromNameList (const List *names)
char *	NameListToString (const List *names)
char *	NameListToQuotedString (const 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)
ProcNumber	GetTempNamespaceProcNumber (Oid namespaceId)
Oid	GetTempToastNamespace (void)
void	GetTempNamespaceState (Oid *tempNamespaceId, Oid *tempToastNamespaceId)
void	SetTempNamespaceState (Oid tempNamespaceId, Oid tempToastNamespaceId)
SearchPathMatcher *	GetSearchPathMatcher (MemoryContext context)
SearchPathMatcher *	CopySearchPathMatcher (SearchPathMatcher *path)
bool	SearchPathMatchesCurrentEnvironment (SearchPathMatcher *path)
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)
static List *	preprocessNamespacePath (const char *searchPath, Oid roleid, bool *temp_missing)
static List *	finalNamespacePath (List *oidlist, Oid *firstNS)
static const SearchPathCacheEntry *	cachedNamespacePath (const char *searchPath, Oid roleid)
void	AtEOXact_Namespace (bool isCommit, bool parallel)
void	AtEOSubXact_Namespace (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)
void	ResetTempTableNamespace (void)
bool	check_search_path (char **newval, void **extra, GucSource source)
void	assign_search_path (const char *newval, void *extra)
void	InitializeSearchPath (void)
List *	fetch_search_path (bool includeImplicit)
int	fetch_search_path_array (Oid *sarray, int sarray_len)
Datum	pg_table_is_visible (PG_FUNCTION_ARGS)
Datum	pg_type_is_visible (PG_FUNCTION_ARGS)
Datum	pg_function_is_visible (PG_FUNCTION_ARGS)
Datum	pg_operator_is_visible (PG_FUNCTION_ARGS)
Datum	pg_opclass_is_visible (PG_FUNCTION_ARGS)
Datum	pg_opfamily_is_visible (PG_FUNCTION_ARGS)
Datum	pg_collation_is_visible (PG_FUNCTION_ARGS)
Datum	pg_conversion_is_visible (PG_FUNCTION_ARGS)
Datum	pg_statistics_obj_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_parser_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_dict_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_template_is_visible (PG_FUNCTION_ARGS)
Datum	pg_ts_config_is_visible (PG_FUNCTION_ARGS)
Datum	pg_my_temp_schema (PG_FUNCTION_ARGS)
Datum	pg_is_other_temp_schema (PG_FUNCTION_ARGS)

Variables
static List *	activeSearchPath = NIL
static Oid	activeCreationNamespace = InvalidOid
static bool	activeTempCreationPending = false
static uint64	activePathGeneration = 1
static List *	baseSearchPath = NIL
static Oid	baseCreationNamespace = InvalidOid
static bool	baseTempCreationPending = false
static Oid	namespaceUser = InvalidOid
static bool	baseSearchPathValid = true
static bool	searchPathCacheValid = false
static MemoryContext	SearchPathCacheContext = NULL
static Oid	myTempNamespace = InvalidOid
static Oid	myTempToastNamespace = InvalidOid
static SubTransactionId	myTempNamespaceSubID = InvalidSubTransactionId
char *	namespace_search_path = NULL
static nsphash_hash *	SearchPathCache = NULL
static SearchPathCacheEntry *	LastSearchPathCacheEntry = NULL

Macro Definition Documentation

SH_DECLARE

#define SH_DECLARE

Definition at line 287 of file namespace.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 288 of file namespace.c.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   SearchPathCacheEntry

Definition at line 281 of file namespace.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		spcachekey_equal(a, b)

Definition at line 285 of file namespace.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		spcachekey_hash(key)

Definition at line 284 of file namespace.c.

SH_KEY

#define SH_KEY   key

Definition at line 283 of file namespace.c.

SH_KEY_TYPE

#define SH_KEY_TYPE   SearchPathCacheKey

Definition at line 282 of file namespace.c.

SH_PREFIX

#define SH_PREFIX   nsphash

Definition at line 280 of file namespace.c.

SH_SCOPE

#define SH_SCOPE   static inline

Definition at line 286 of file namespace.c.

SPACE_PER_OP

#define SPACE_PER_OP

Value:

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

SPCACHE_RESET_THRESHOLD

#define SPCACHE_RESET_THRESHOLD   256

Definition at line 297 of file namespace.c.

Typedef Documentation

SearchPathCacheEntry

typedef struct SearchPathCacheEntry SearchPathCacheEntry

SearchPathCacheKey

typedef struct SearchPathCacheKey SearchPathCacheKey

Function Documentation

AccessTempTableNamespace()

static void AccessTempTableNamespace ( bool  force )

static

Definition at line 4362 of file namespace.c.

{
    /*
     * Make note that this temporary namespace has been accessed in this
     * transaction.
     */
    MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;
 
    /*
     * If the caller attempting to access a temporary schema expects the
     * creation of the namespace to be pending and should be enforced, then go
     * through the creation.
     */
    if (!force && OidIsValid(myTempNamespace))
        return;
 
    /*
     * The temporary tablespace does not exist yet and is wanted, so
     * initialize it.
     */
    InitTempTableNamespace();
}

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

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

assign_search_path()

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

Definition at line 4713 of file namespace.c.

{
    /* don't access search_path during bootstrap */
    Assert(!IsBootstrapProcessingMode());
 
    /*
     * We mark the path as needing recomputation, but don't do anything until
     * it's needed.  This avoids trying to do database access during GUC
     * initialization, or outside a transaction.
     *
     * This does not invalidate the search path cache, so if this value had
     * been previously set and no syscache invalidations happened,
     * recomputation may not be necessary.
     */
    baseSearchPathValid = false;
}

References Assert, baseSearchPathValid, and IsBootstrapProcessingMode.

AtEOSubXact_Namespace()

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

Definition at line 4558 of file namespace.c.

{
 
    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 */
            searchPathCacheValid = false;
 
            /*
             * 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;
        }
    }
}

References baseSearchPathValid, InvalidOid, InvalidSubTransactionId, MyProc, myTempNamespace, myTempNamespaceSubID, myTempToastNamespace, searchPathCacheValid, and PGPROC::tempNamespaceId.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_Namespace()

void AtEOXact_Namespace	(	bool	isCommit,
		bool	parallel
	)

Definition at line 4512 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 */
            searchPathCacheValid = false;
 
            /*
             * 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;
    }
 
}

References baseSearchPathValid, before_shmem_exit(), InvalidOid, InvalidSubTransactionId, MyProc, myTempNamespace, myTempNamespaceSubID, myTempToastNamespace, RemoveTempRelationsCallback(), searchPathCacheValid, and PGPROC::tempNamespaceId.

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

cachedNamespacePath()

static const SearchPathCacheEntry* cachedNamespacePath ( const char *  searchPath, Oid  roleid  )

static

Definition at line 4244 of file namespace.c.

{
    MemoryContext oldcxt;
    SearchPathCacheEntry *entry;
 
    spcache_init();
 
    entry = spcache_insert(searchPath, roleid);
 
    /*
     * An OOM may have resulted in a cache entry with missing 'oidlist' or
     * 'finalPath', so just compute whatever is missing.
     */
 
    if (entry->oidlist == NIL)
    {
        oldcxt = MemoryContextSwitchTo(SearchPathCacheContext);
        entry->oidlist = preprocessNamespacePath(searchPath, roleid,
                                                 &entry->temp_missing);
        MemoryContextSwitchTo(oldcxt);
    }
 
    /*
     * If a hook is set, we must recompute finalPath from the oidlist each
     * time, because the hook may affect the result. This is still much faster
     * than recomputing from the string (and doing catalog lookups and ACL
     * checks).
     */
    if (entry->finalPath == NIL || object_access_hook ||
        entry->forceRecompute)
    {
        list_free(entry->finalPath);
        entry->finalPath = NIL;
 
        oldcxt = MemoryContextSwitchTo(SearchPathCacheContext);
        entry->finalPath = finalNamespacePath(entry->oidlist,
                                              &entry->firstNS);
        MemoryContextSwitchTo(oldcxt);
 
        /*
         * If an object_access_hook is set when finalPath is calculated, the
         * result may be affected by the hook. Force recomputation of
         * finalPath the next time this cache entry is used, even if the
         * object_access_hook is not set at that time.
         */
        entry->forceRecompute = object_access_hook ? true : false;
    }
 
    return entry;
}

References finalNamespacePath(), SearchPathCacheEntry::finalPath, SearchPathCacheEntry::firstNS, SearchPathCacheEntry::forceRecompute, list_free(), MemoryContextSwitchTo(), NIL, object_access_hook, SearchPathCacheEntry::oidlist, preprocessNamespacePath(), SearchPathCacheContext, spcache_init(), spcache_insert(), SearchPathCacheEntry::temp_missing, and true.

Referenced by recomputeNamespacePath().

check_search_path()

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

Definition at line 4657 of file namespace.c.

{
    Oid         roleid = InvalidOid;
    const char *searchPath = *newval;
    char       *rawname;
    List       *namelist;
    bool        use_cache = (SearchPathCacheContext != NULL);
 
    /*
     * We used to try to check that the named schemas exist, but there are
     * many valid use-cases for having search_path settings that include
     * schemas that don't exist; and often, we are not inside a transaction
     * here and so can't consult the system catalogs anyway.  So now, the only
     * requirement is syntactic validity of the identifier list.
     *
     * Checking only the syntactic validity also allows us to use the search
     * path cache (if available) to avoid calling SplitIdentifierString() on
     * the same string repeatedly.
     */
    if (use_cache)
    {
        spcache_init();
 
        roleid = GetUserId();
 
        if (spcache_lookup(searchPath, roleid) != NULL)
            return true;
    }
 
    /*
     * Ensure validity check succeeds before creating cache entry.
     */
 
    rawname = pstrdup(searchPath);  /* need a modifiable copy */
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawname, ',', &namelist))
    {
        /* syntax error in name list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawname);
        list_free(namelist);
        return false;
    }
    pfree(rawname);
    list_free(namelist);
 
    /* OK to create empty cache entry */
    if (use_cache)
        (void) spcache_insert(searchPath, roleid);
 
    return true;
}

References GetUserId(), GUC_check_errdetail, InvalidOid, list_free(), newval, pfree(), pstrdup(), SearchPathCacheContext, spcache_init(), spcache_insert(), spcache_lookup(), and SplitIdentifierString().

CheckSetNamespace()

void CheckSetNamespace	(	Oid	oldNspOid,
		Oid	nspOid
	)

Definition at line 3459 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 3729 of file namespace.c.

{
    PGPROC     *proc;
    ProcNumber  procNumber;
 
    Assert(OidIsValid(MyDatabaseId));
 
    procNumber = GetTempNamespaceProcNumber(namespaceId);
 
    /* No such namespace, or its name shows it's not temp? */
    if (procNumber == INVALID_PROC_NUMBER)
        return TEMP_NAMESPACE_NOT_TEMP;
 
    /* Is the backend alive? */
    proc = ProcNumberGetProc(procNumber);
    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, PGPROC::databaseId, GetTempNamespaceProcNumber(), INVALID_PROC_NUMBER, MyDatabaseId, OidIsValid, ProcNumberGetProc(), 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 2373 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, collid, GetDatabaseEncoding(), InvalidOid, lfirst_oid, lookup_collation(), myTempNamespace, OidIsValid, and recomputeNamespacePath().

Referenced by CollationIsVisibleExt().

CollationIsVisible()

bool CollationIsVisible

(

Oid

collid

)

Definition at line 2407 of file namespace.c.

{
    return CollationIsVisibleExt(collid, NULL);
}

References CollationIsVisibleExt(), and collid.

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

CollationIsVisibleExt()

static bool CollationIsVisibleExt ( Oid  collid, bool *  is_missing  )

static

Definition at line 2419 of file namespace.c.

{
    HeapTuple   colltup;
    Form_pg_collation collform;
    Oid         collnamespace;
    bool        visible;
 
    colltup = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
    if (!HeapTupleIsValid(colltup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), collid, elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by CollationIsVisible(), and pg_collation_is_visible().

ConversionGetConid()

Oid ConversionGetConid

(

const char *

conname

)

Definition at line 2477 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, GetSysCacheOid2, InvalidOid, lfirst_oid, myTempNamespace, ObjectIdGetDatum(), OidIsValid, PointerGetDatum(), and recomputeNamespacePath().

Referenced by ConversionIsVisibleExt().

ConversionIsVisible()

bool ConversionIsVisible

(

Oid

conid

)

Definition at line 2509 of file namespace.c.

{
    return ConversionIsVisibleExt(conid, NULL);
}

References ConversionIsVisibleExt().

Referenced by getObjectDescription().

ConversionIsVisibleExt()

static bool ConversionIsVisibleExt ( Oid  conid, bool *  is_missing  )

static

Definition at line 2521 of file namespace.c.

{
    HeapTuple   contup;
    Form_pg_conversion conform;
    Oid         connamespace;
    bool        visible;
 
    contup = SearchSysCache1(CONVOID, ObjectIdGetDatum(conid));
    if (!HeapTupleIsValid(contup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by ConversionIsVisible(), and pg_conversion_is_visible().

CopySearchPathMatcher()

SearchPathMatcher* CopySearchPathMatcher

(

SearchPathMatcher *

path

)

Definition at line 3889 of file namespace.c.

{
    SearchPathMatcher *result;
 
    result = (SearchPathMatcher *) palloc(sizeof(SearchPathMatcher));
    result->schemas = list_copy(path->schemas);
    result->addCatalog = path->addCatalog;
    result->addTemp = path->addTemp;
    result->generation = path->generation;
 
    return result;
}

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

Referenced by CopyCachedPlan().

DeconstructQualifiedName()

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

Definition at line 3301 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 4819 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 4859 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().

finalNamespacePath()

static List* finalNamespacePath ( List *  oidlist, Oid *  firstNS  )

static

Definition at line 4198 of file namespace.c.

{
    List       *finalPath = NIL;
    ListCell   *lc;
 
    foreach(lc, oidlist)
    {
        Oid         namespaceId = lfirst_oid(lc);
 
        if (!list_member_oid(finalPath, namespaceId))
        {
            if (InvokeNamespaceSearchHook(namespaceId, false))
                finalPath = lappend_oid(finalPath, namespaceId);
        }
    }
 
    /*
     * Remember the first member of the explicit list.  (Note: this is
     * nominally wrong if temp_missing, but we need it anyway to distinguish
     * explicit from implicit mention of pg_catalog.)
     */
    if (finalPath == NIL)
        *firstNS = InvalidOid;
    else
        *firstNS = linitial_oid(finalPath);
 
    /*
     * 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 (!list_member_oid(finalPath, PG_CATALOG_NAMESPACE))
        finalPath = lcons_oid(PG_CATALOG_NAMESPACE, finalPath);
 
    if (OidIsValid(myTempNamespace) &&
        !list_member_oid(finalPath, myTempNamespace))
        finalPath = lcons_oid(myTempNamespace, finalPath);
 
    return finalPath;
}

References InvalidOid, InvokeNamespaceSearchHook, lappend_oid(), lcons_oid(), lfirst_oid, linitial_oid, list_member_oid(), myTempNamespace, NIL, and OidIsValid.

Referenced by cachedNamespacePath().

FindDefaultConversionProc()

Oid FindDefaultConversionProc	(	int32	for_encoding,
		int32	to_encoding
	)

Definition at line 4080 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 1192 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 */
            for (int j = 0; j < pronargs; j++)
                newResult->args[j] = proargtypes[argnumbers[j]];
        }
        else
        {
            /* Simple positional case, just copy proargtypes as-is */
            memcpy(newResult->args, proargtypes, pronargs * sizeof(Oid));
        }
        if (variadic)
        {
            newResult->nvargs = effective_nargs - pronargs + 1;
            /* Expand variadic argument into N copies of element type */
            for (int j = pronargs - 1; j < effective_nargs; j++)
                newResult->args[j] = 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, funcname, GETSTRUCT, i, InvalidOid, j, lfirst_oid, LookupExplicitNamespace(), MatchNamedCall(), Max, catclist::members, myTempNamespace, catclist::n_members, _FuncCandidateList::nargs, _FuncCandidateList::ndargs, _FuncCandidateList::next, NIL, _FuncCandidateList::nominalnargs, _FuncCandidateList::nvargs, _FuncCandidateList::oid, OidIsValid, catclist::ordered, palloc(), _FuncCandidateList::pathpos, pfree(), pronargs, recomputeNamespacePath(), ReleaseSysCacheList, SearchSysCacheList1, SysCacheGetAttr(), and catctup::tuple.

Referenced by func_get_detail(), FunctionIsVisibleExt(), LookupFuncNameInternal(), regprocedurein(), regprocin(), and regprocout().

FunctionIsVisible()

bool FunctionIsVisible

(

Oid

funcid

)

Definition at line 1696 of file namespace.c.

{
    return FunctionIsVisibleExt(funcid, NULL);
}

References FunctionIsVisibleExt().

Referenced by format_procedure_extended().

FunctionIsVisibleExt()

static bool FunctionIsVisibleExt ( Oid  funcid, bool *  is_missing  )

static

Definition at line 1708 of file namespace.c.

{
    HeapTuple   proctup;
    Form_pg_proc procform;
    Oid         pronamespace;
    bool        visible;
 
    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(proctup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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, proname, recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by FunctionIsVisible(), and pg_function_is_visible().

get_collation_oid()

Oid get_collation_oid	(	List *	collname,
		bool	missing_ok
	)

Definition at line 3971 of file namespace.c.

{
    char       *schemaname;
    char       *collation_name;
    int32       dbencoding = GetDatabaseEncoding();
    Oid         namespaceId;
    Oid         colloid;
    ListCell   *l;
 
    /* deconstruct the name list */
    DeconstructQualifiedName(collname, &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(collname), GetDatabaseEncodingName())));
    return InvalidOid;
}

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

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

get_conversion_oid()

Oid get_conversion_oid	(	List *	conname,
		bool	missing_ok
	)

Definition at line 4025 of file namespace.c.

{
    char       *schemaname;
    char       *conversion_name;
    Oid         namespaceId;
    Oid         conoid = InvalidOid;
    ListCell   *l;
 
    /* deconstruct the name list */
    DeconstructQualifiedName(conname, &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(conname))));
    return conoid;
}

References activeSearchPath, DeconstructQualifiedName(), ereport, errcode(), errmsg(), ERROR, GetSysCacheOid2, InvalidOid, lfirst_oid, LookupExplicitNamespace(), myTempNamespace, 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 3535 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, and OidIsValid.

Referenced by binary_upgrade_create_empty_extension(), convert_schema_name(), CreateExtensionInternal(), CreateSchemaCommand(), get_object_address_defacl(), get_object_address_publication_schema(), get_object_address_unqualified(), InitTempTableNamespace(), LookupCreationNamespace(), LookupExplicitNamespace(), LookupNamespaceNoError(), objectNamesToOids(), ObjectsInPublicationToOids(), preprocessNamespacePath(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), regnamespacein(), ReindexMultipleTables(), RenameSchema(), and SetDefaultACLsInSchemas().

get_statistics_object_oid()

Oid get_statistics_object_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 2575 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(), and recomputeNamespacePath().

Referenced by AlterStatistics(), and get_object_address().

get_ts_config_oid()

Oid get_ts_config_oid	(	List *	names,
		bool	missing_ok
	)

Definition at line 3152 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(), and recomputeNamespacePath().

Referenced by check_default_text_search_config(), 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 2861 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(), and recomputeNamespacePath().

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 2716 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(), and recomputeNamespacePath().

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 3007 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(), and recomputeNamespacePath().

Referenced by DefineTSDictionary(), and get_object_address().

GetSearchPathMatcher()

SearchPathMatcher* GetSearchPathMatcher

(

MemoryContext

context

)

Definition at line 3852 of file namespace.c.

{
    SearchPathMatcher *result;
    List       *schemas;
    MemoryContext oldcxt;
 
    recomputeNamespacePath();
 
    oldcxt = MemoryContextSwitchTo(context);
 
    result = (SearchPathMatcher *) palloc0(sizeof(SearchPathMatcher));
    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, SearchPathMatcher::addCatalog, SearchPathMatcher::addTemp, Assert, context, SearchPathMatcher::generation, linitial_oid, list_copy(), list_delete_first(), MemoryContextSwitchTo(), myTempNamespace, palloc0(), recomputeNamespacePath(), and SearchPathMatcher::schemas.

Referenced by CompleteCachedPlan(), and RevalidateCachedQuery().

GetTempNamespaceProcNumber()

ProcNumber GetTempNamespaceProcNumber

(

Oid

namespaceId

)

Definition at line 3766 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 INVALID_PROC_NUMBER; /* 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 = INVALID_PROC_NUMBER;
    pfree(nspname);
    return result;
}

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

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

GetTempNamespaceState()

void GetTempNamespaceState	(	Oid *	tempNamespaceId,
		Oid *	tempToastNamespaceId
	)

Definition at line 3805 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 3791 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 4736 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
         * that will affect the search_path cache.
         */
 
        /* namespace name or ACLs may have changed */
        CacheRegisterSyscacheCallback(NAMESPACEOID,
                                      InvalidationCallback,
                                      (Datum) 0);
 
        /* role name may affect the meaning of "$user" */
        CacheRegisterSyscacheCallback(AUTHOID,
                                      InvalidationCallback,
                                      (Datum) 0);
 
        /* role membership may affect ACLs */
        CacheRegisterSyscacheCallback(AUTHMEMROLEMEM,
                                      InvalidationCallback,
                                      (Datum) 0);
 
        /* database owner may affect ACLs */
        CacheRegisterSyscacheCallback(DATABASEOID,
                                      InvalidationCallback,
                                      (Datum) 0);
 
        /* Force search path to be recomputed on next use */
        baseSearchPathValid = false;
        searchPathCacheValid = false;
    }
}

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

Referenced by InitPostgres().

InitTempTableNamespace()

static void InitTempTableNamespace ( void  )

static

Definition at line 4390 of file namespace.c.

{
    char        namespaceName[NAMEDATALEN];
    Oid         namespaceId;
    Oid         toastspaceId;
 
    Assert(!OidIsValid(myTempNamespace));
 
    /*
     * First, do permission check to see if we are authorized to make temp
     * tables.  We use a nonstandard error message here since "databasename:
     * permission denied" might be a tad cryptic.
     *
     * Note that ACL_CREATE_TEMP rights are rechecked in pg_namespace_aclmask;
     * that's necessary since current user ID could change during the session.
     * But there's no need to make the namespace in the first place until a
     * temp table creation request is made by someone with appropriate rights.
     */
    if (object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(),
                        ACL_CREATE_TEMP) != ACLCHECK_OK)
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create temporary tables in database \"%s\"",
                        get_database_name(MyDatabaseId))));
 
    /*
     * Do not allow a Hot Standby session to make temp tables.  Aside from
     * problems with modifying the system catalogs, there is a naming
     * conflict: pg_temp_N belongs to the session with proc number N on the
     * primary, not to a hot standby session with the same proc number.  We
     * should not be able to get here anyway due to XactReadOnly checks, but
     * let's just make real sure.  Note that this also backstops various
     * operations that allow XactReadOnly transactions to modify temp tables;
     * they'd need RecoveryInProgress checks if not for this.
     */
    if (RecoveryInProgress())
        ereport(ERROR,
                (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
                 errmsg("cannot create temporary tables during recovery")));
 
    /* Parallel workers can't create temporary tables, either. */
    if (IsParallelWorker())
        ereport(ERROR,
                (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
                 errmsg("cannot create temporary tables during a parallel operation")));
 
    snprintf(namespaceName, sizeof(namespaceName), "pg_temp_%d", MyProcNumber);
 
    namespaceId = get_namespace_oid(namespaceName, true);
    if (!OidIsValid(namespaceId))
    {
        /*
         * First use of this temp namespace in this database; create it. The
         * temp namespaces are always owned by the superuser.  We leave their
         * permissions at default --- i.e., no access except to superuser ---
         * to ensure that unprivileged users can't peek at other backends'
         * temp tables.  This works because the places that access the temp
         * namespace for my own backend skip permissions checks on it.
         */
        namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID,
                                      true);
        /* Advance command counter to make namespace visible */
        CommandCounterIncrement();
    }
    else
    {
        /*
         * If the namespace already exists, clean it out (in case the former
         * owner crashed without doing so).
         */
        RemoveTempRelations(namespaceId);
    }
 
    /*
     * If the corresponding toast-table namespace doesn't exist yet, create
     * it. (We assume there is no need to clean it out if it does exist, since
     * dropping a parent table should make its toast table go away.)
     */
    snprintf(namespaceName, sizeof(namespaceName), "pg_toast_temp_%d",
             MyProcNumber);
 
    toastspaceId = get_namespace_oid(namespaceName, true);
    if (!OidIsValid(toastspaceId))
    {
        toastspaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID,
                                       true);
        /* Advance command counter to make namespace visible */
        CommandCounterIncrement();
    }
 
    /*
     * Okay, we've prepared the temp namespace ... but it's not committed yet,
     * so all our work could be undone by transaction rollback.  Set flag for
     * AtEOXact_Namespace to know what to do.
     */
    myTempNamespace = namespaceId;
    myTempToastNamespace = toastspaceId;
 
    /*
     * Mark MyProc as owning this namespace which other processes can use to
     * decide if a temporary namespace is in use or not.  We assume that
     * assignment of namespaceId is an atomic operation.  Even if it is not,
     * the temporary relation which resulted in the creation of this temporary
     * namespace is still locked until the current transaction commits, and
     * its pg_namespace row is not visible yet.  However it does not matter:
     * this flag makes the namespace as being in use, so no objects created on
     * it would be removed concurrently.
     */
    MyProc->tempNamespaceId = namespaceId;
 
    /* It should not be done already. */
    Assert(myTempNamespaceSubID == InvalidSubTransactionId);
    myTempNamespaceSubID = GetCurrentSubTransactionId();
 
    baseSearchPathValid = false;    /* need to rebuild list */
    searchPathCacheValid = false;
}

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

Referenced by AccessTempTableNamespace().

InvalidationCallback()

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

static

Definition at line 4796 of file namespace.c.

{
    /*
     * Force search path to be recomputed on next use, also invalidating the
     * search path cache (because namespace names, ACLs, or role names may
     * have changed).
     */
    baseSearchPathValid = false;
    searchPathCacheValid = false;
}

References baseSearchPathValid, and searchPathCacheValid.

Referenced by InitializeSearchPath().

isAnyTempNamespace()

bool isAnyTempNamespace

(

Oid

namespaceId

)

Definition at line 3687 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 3710 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 3649 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_ext(), ReindexMultipleTables(), and RemoveObjects().

isTempOrTempToastNamespace()

bool isTempOrTempToastNamespace

(

Oid

namespaceId

)

Definition at line 3673 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 3661 of file namespace.c.

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

References myTempToastNamespace, and OidIsValid.

Referenced by IsToastNamespace().

lookup_collation()

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

static

Definition at line 2322 of file namespace.c.

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

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

Referenced by CollationGetCollid(), and get_collation_oid().

LookupCreationNamespace()

Oid LookupCreationNamespace

(

const char *

nspname

)

Definition at line 3428 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 = object_aclcheck(NamespaceRelationId, 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_aclcheck(), and OBJECT_SCHEMA.

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

LookupExplicitNamespace()

Oid LookupExplicitNamespace	(	const char *	nspname,
		bool	missing_ok
	)

Definition at line 3385 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 = object_aclcheck(NamespaceRelationId, 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_aclcheck(), OBJECT_SCHEMA, and OidIsValid.

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 3355 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

(

const List *

names

)

Definition at line 3554 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_multi_page_stats(), 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(), plpgsql_parse_cwordrowtype(), plpgsql_parse_cwordtype(), process_owned_by(), regclassin(), RelationNameGetTupleDesc(), RemoveRelations(), row_security_active_name(), schema_does_not_exist_skipping(), and text_regclass().

MatchNamedCall()

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

static

Definition at line 1585 of file namespace.c.

{
    Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
    int         numposargs = nargs - list_length(argnames);
    int         pronallargs;
    Oid        *p_argtypes;
    char      **p_argnames;
    char       *p_argmodes;
    bool        arggiven[FUNC_MAX_ARGS];
    bool        isnull;
    int         ap;             /* call args position */
    int         pp;             /* proargs position */
    ListCell   *lc;
 
    Assert(argnames != NIL);
    Assert(numposargs >= 0);
    Assert(nargs <= pronargs);
 
    /* Ignore this function if its proargnames is null */
    (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_proargnames,
                           &isnull);
    if (isnull)
        return false;
 
    /* OK, let's extract the argument names and types */
    pronallargs = get_func_arg_info(proctup,
                                    &p_argtypes, &p_argnames, &p_argmodes);
    Assert(p_argnames != NULL);
 
    Assert(include_out_arguments ? (pronargs == pronallargs) : (pronargs <= pronallargs));
 
    /* initialize state for matching */
    *argnumbers = (int *) palloc(pronargs * sizeof(int));
    memset(arggiven, false, pronargs * sizeof(bool));
 
    /* there are numposargs positional args before the named args */
    for (ap = 0; ap < numposargs; ap++)
    {
        (*argnumbers)[ap] = ap;
        arggiven[ap] = true;
    }
 
    /* now examine the named args */
    foreach(lc, argnames)
    {
        char       *argname = (char *) lfirst(lc);
        bool        found;
        int         i;
 
        pp = 0;
        found = false;
        for (i = 0; i < pronallargs; i++)
        {
            /* consider only input params, except with include_out_arguments */
            if (!include_out_arguments &&
                p_argmodes &&
                (p_argmodes[i] != FUNC_PARAM_IN &&
                 p_argmodes[i] != FUNC_PARAM_INOUT &&
                 p_argmodes[i] != FUNC_PARAM_VARIADIC))
                continue;
            if (p_argnames[i] && strcmp(p_argnames[i], argname) == 0)
            {
                /* fail if argname matches a positional argument */
                if (arggiven[pp])
                    return false;
                arggiven[pp] = true;
                (*argnumbers)[ap] = pp;
                found = true;
                break;
            }
            /* increase pp only for considered parameters */
            pp++;
        }
        /* if name isn't in proargnames, fail */
        if (!found)
            return false;
        ap++;
    }
 
    Assert(ap == nargs);        /* processed all actual parameters */
 
    /* Check for default arguments */
    if (nargs < pronargs)
    {
        int         first_arg_with_default = pronargs - procform->pronargdefaults;
 
        for (pp = numposargs; pp < pronargs; pp++)
        {
            if (arggiven[pp])
                continue;
            /* fail if arg not given and no default available */
            if (pp < first_arg_with_default)
                return false;
            (*argnumbers)[ap++] = pp;
        }
    }
 
    Assert(ap == pronargs);     /* processed all function parameters */
 
    return true;
}

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

Referenced by FuncnameGetCandidates().

NameListToQuotedString()

char* NameListToQuotedString

(

const List *

names

)

Definition at line 3628 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

(

const List *

names

)

Definition at line 3594 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(), regclassin(), regcollationin(), regconfigin(), regdictionaryin(), RemoveObjects(), ResolveOpClass(), storeOperators(), storeProcedures(), transformColumnRef(), transformRangeTableSample(), ValidateJoinEstimator(), ValidateOperatorReference(), and ValidateRestrictionEstimator().

OpclassIsVisible()

bool OpclassIsVisible

(

Oid

opcid

)

Definition at line 2154 of file namespace.c.

{
    return OpclassIsVisibleExt(opcid, NULL);
}

References OpclassIsVisibleExt().

Referenced by get_opclass_name(), and getObjectDescription().

OpclassIsVisibleExt()

static bool OpclassIsVisibleExt ( Oid  opcid, bool *  is_missing  )

static

Definition at line 2166 of file namespace.c.

{
    HeapTuple   opctup;
    Form_pg_opclass opcform;
    Oid         opcnamespace;
    bool        visible;
 
    opctup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opcid));
    if (!HeapTupleIsValid(opctup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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, elog, ERROR, GETSTRUCT, HeapTupleIsValid, list_member_oid(), NameStr, ObjectIdGetDatum(), OpclassnameGetOpcid(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by OpclassIsVisible(), and pg_opclass_is_visible().

OpclassnameGetOpcid()

Oid OpclassnameGetOpcid	(	Oid	amid,
		const char *	opcname
	)

Definition at line 2121 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, GetSysCacheOid3, InvalidOid, lfirst_oid, myTempNamespace, ObjectIdGetDatum(), OidIsValid, PointerGetDatum(), and recomputeNamespacePath().

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

OperatorIsVisible()

bool OperatorIsVisible

(

Oid

oprid

)

Definition at line 2049 of file namespace.c.

{
    return OperatorIsVisibleExt(oprid, NULL);
}

References OperatorIsVisibleExt(), and oprid().

Referenced by format_operator_extended().

OperatorIsVisibleExt()

static bool OperatorIsVisibleExt ( Oid  oprid, bool *  is_missing  )

static

Definition at line 2061 of file namespace.c.

{
    HeapTuple   oprtup;
    Form_pg_operator oprform;
    Oid         oprnamespace;
    bool        visible;
 
    oprtup = SearchSysCache1(OPEROID, ObjectIdGetDatum(oprid));
    if (!HeapTupleIsValid(oprtup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), oprid(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by OperatorIsVisible(), and pg_operator_is_visible().

OpernameGetCandidates()

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

Definition at line 1888 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, catclist::ordered, palloc(), _FuncCandidateList::pathpos, recomputeNamespacePath(), ReleaseSysCacheList, SearchSysCacheList1, SPACE_PER_OP, and catctup::tuple.

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

OpernameGetOprid()

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

Definition at line 1785 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, recomputeNamespacePath(), ReleaseSysCache(), ReleaseSysCacheList, SearchSysCache4(), SearchSysCacheList3, and catctup::tuple.

Referenced by binary_oper_exact(), left_oper(), LookupOperName(), OperatorIsVisibleExt(), and regoperatorin().

OpfamilyIsVisible()

bool OpfamilyIsVisible

(

Oid

opfid

)

Definition at line 2256 of file namespace.c.

{
    return OpfamilyIsVisibleExt(opfid, NULL);
}

References OpfamilyIsVisibleExt().

Referenced by getOpFamilyDescription().

OpfamilyIsVisibleExt()

static bool OpfamilyIsVisibleExt ( Oid  opfid, bool *  is_missing  )

static

Definition at line 2268 of file namespace.c.

{
    HeapTuple   opftup;
    Form_pg_opfamily opfform;
    Oid         opfnamespace;
    bool        visible;
 
    opftup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
    if (!HeapTupleIsValid(opftup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), recomputeNamespacePath(), ReleaseSysCache(), and SearchSysCache1().

Referenced by OpfamilyIsVisible(), and pg_opfamily_is_visible().

OpfamilynameGetOpfid()

Oid OpfamilynameGetOpfid	(	Oid	amid,
		const char *	opfname
	)

Definition at line 2223 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, PointerGetDatum(), and recomputeNamespacePath().

Referenced by OpFamilyCacheLookup(), and OpfamilyIsVisibleExt().

pg_collation_is_visible()

Datum pg_collation_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4978 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = CollationIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References CollationIsVisibleExt(), PG_GETARG_OID, PG_RETURN_BOOL, and PG_RETURN_NULL.

pg_conversion_is_visible()

Datum pg_conversion_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4992 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = ConversionIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References ConversionIsVisibleExt(), PG_GETARG_OID, PG_RETURN_BOOL, and PG_RETURN_NULL.

pg_function_is_visible()

Datum pg_function_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4922 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = FunctionIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References FunctionIsVisibleExt(), PG_GETARG_OID, PG_RETURN_BOOL, and PG_RETURN_NULL.

pg_is_other_temp_schema()

Datum pg_is_other_temp_schema

(

PG_FUNCTION_ARGS

)

Definition at line 5082 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
 
    PG_RETURN_BOOL(isOtherTempNamespace(oid));
}

References isOtherTempNamespace(), PG_GETARG_OID, and PG_RETURN_BOOL.

pg_my_temp_schema()

Datum pg_my_temp_schema

(

PG_FUNCTION_ARGS

)

Definition at line 5076 of file namespace.c.

{
    PG_RETURN_OID(myTempNamespace);
}

References myTempNamespace, and PG_RETURN_OID.

pg_opclass_is_visible()

Datum pg_opclass_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4950 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = OpclassIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References OpclassIsVisibleExt(), PG_GETARG_OID, PG_RETURN_BOOL, and PG_RETURN_NULL.

pg_operator_is_visible()

Datum pg_operator_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4936 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = OperatorIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References OperatorIsVisibleExt(), PG_GETARG_OID, PG_RETURN_BOOL, and PG_RETURN_NULL.

pg_opfamily_is_visible()

Datum pg_opfamily_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4964 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = OpfamilyIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References OpfamilyIsVisibleExt(), PG_GETARG_OID, PG_RETURN_BOOL, and PG_RETURN_NULL.

pg_statistics_obj_is_visible()

Datum pg_statistics_obj_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 5006 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = StatisticsObjIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and StatisticsObjIsVisibleExt().

pg_table_is_visible()

Datum pg_table_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4894 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = RelationIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and RelationIsVisibleExt().

pg_ts_config_is_visible()

Datum pg_ts_config_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 5062 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = TSConfigIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and TSConfigIsVisibleExt().

pg_ts_dict_is_visible()

Datum pg_ts_dict_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 5034 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = TSDictionaryIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and TSDictionaryIsVisibleExt().

pg_ts_parser_is_visible()

Datum pg_ts_parser_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 5020 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = TSParserIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and TSParserIsVisibleExt().

pg_ts_template_is_visible()

Datum pg_ts_template_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 5048 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = TSTemplateIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and TSTemplateIsVisibleExt().

pg_type_is_visible()

Datum pg_type_is_visible

(

PG_FUNCTION_ARGS

)

Definition at line 4908 of file namespace.c.

{
    Oid         oid = PG_GETARG_OID(0);
    bool        result;
    bool        is_missing = false;
 
    result = TypeIsVisibleExt(oid, &is_missing);
 
    if (is_missing)
        PG_RETURN_NULL();
    PG_RETURN_BOOL(result);
}

References PG_GETARG_OID, PG_RETURN_BOOL, PG_RETURN_NULL, and TypeIsVisibleExt().

preprocessNamespacePath()

static List* preprocessNamespacePath ( const char *  searchPath, Oid  roleid, bool *  temp_missing  )

static

Definition at line 4107 of file namespace.c.

{
    char       *rawname;
    List       *namelist;
    List       *oidlist;
    ListCell   *l;
 
    /* Need a modifiable copy */
    rawname = pstrdup(searchPath);
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawname, ',', &namelist))
    {
        /* syntax error in name list */
        /* this should not happen if GUC checked check_search_path */
        elog(ERROR, "invalid list syntax");
    }
 
    /*
     * Convert the list of names to a list of OIDs.  If any names are not
     * recognizable or we don't have read access, just leave them out of the
     * list.  (We can't raise an error, since the search_path setting has
     * already been accepted.)  Don't make duplicate entries, either.
     */
    oidlist = NIL;
    *temp_missing = false;
    foreach(l, namelist)
    {
        char       *curname = (char *) lfirst(l);
        Oid         namespaceId;
 
        if (strcmp(curname, "$user") == 0)
        {
            /* $user --- substitute namespace matching user name, if any */
            HeapTuple   tuple;
 
            tuple = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
            if (HeapTupleIsValid(tuple))
            {
                char       *rname;
 
                rname = NameStr(((Form_pg_authid) GETSTRUCT(tuple))->rolname);
                namespaceId = get_namespace_oid(rname, true);
                ReleaseSysCache(tuple);
                if (OidIsValid(namespaceId) &&
                    object_aclcheck(NamespaceRelationId, namespaceId, roleid,
                                    ACL_USAGE) == ACLCHECK_OK)
                    oidlist = lappend_oid(oidlist, namespaceId);
            }
        }
        else if (strcmp(curname, "pg_temp") == 0)
        {
            /* pg_temp --- substitute temp namespace, if any */
            if (OidIsValid(myTempNamespace))
                oidlist = lappend_oid(oidlist, myTempNamespace);
            else
            {
                /* If it ought to be the creation namespace, set flag */
                if (oidlist == NIL)
                    *temp_missing = true;
            }
        }
        else
        {
            /* normal namespace reference */
            namespaceId = get_namespace_oid(curname, true);
            if (OidIsValid(namespaceId) &&
                object_aclcheck(NamespaceRelationId, namespaceId, roleid,
                                ACL_USAGE) == ACLCHECK_OK)
                oidlist = lappend_oid(oidlist, namespaceId);
        }
    }
 
    pfree(rawname);
    list_free(namelist);
 
    return oidlist;
}

References ACL_USAGE, ACLCHECK_OK, elog, ERROR, get_namespace_oid(), GETSTRUCT, HeapTupleIsValid, lappend_oid(), lfirst, list_free(), myTempNamespace, NameStr, NIL, object_aclcheck(), ObjectIdGetDatum(), OidIsValid, pfree(), pstrdup(), ReleaseSysCache(), rolname, SearchSysCache1(), and SplitIdentifierString().

Referenced by cachedNamespacePath().

QualifiedNameGetCreationNamespace()

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

Definition at line 3487 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 846 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(), nspid, and RangeVar::relpersistence.

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

RangeVarGetAndCheckCreationNamespace()

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

Definition at line 739 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 = object_aclcheck(NamespaceRelationId, 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 (!object_ownercheck(RelationRelationId, 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, nspid, object_aclcheck(), object_ownercheck(), OBJECT_SCHEMA, OidIsValid, 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 654 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 441 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().

recomputeNamespacePath()

static void recomputeNamespacePath ( void  )

static

Definition at line 4299 of file namespace.c.

{
    Oid         roleid = GetUserId();
    bool        pathChanged;
    const SearchPathCacheEntry *entry;
 
    /* Do nothing if path is already valid. */
    if (baseSearchPathValid && namespaceUser == roleid)
        return;
 
    entry = cachedNamespacePath(namespace_search_path, roleid);
 
    if (baseCreationNamespace == entry->firstNS &&
        baseTempCreationPending == entry->temp_missing &&
        equal(entry->finalPath, baseSearchPath))
    {
        pathChanged = false;
    }
    else
    {
        MemoryContext oldcxt;
        List       *newpath;
 
        pathChanged = true;
 
        /* Must save OID list in permanent storage. */
        oldcxt = MemoryContextSwitchTo(TopMemoryContext);
        newpath = list_copy(entry->finalPath);
        MemoryContextSwitchTo(oldcxt);
 
        /* Now safe to assign to state variables. */
        list_free(baseSearchPath);
        baseSearchPath = newpath;
        baseCreationNamespace = entry->firstNS;
        baseTempCreationPending = entry->temp_missing;
    }
 
    /* Mark the path valid. */
    baseSearchPathValid = true;
    namespaceUser = roleid;
 
    /* And make it active. */
    activeSearchPath = baseSearchPath;
    activeCreationNamespace = baseCreationNamespace;
    activeTempCreationPending = baseTempCreationPending;
 
    /*
     * Bump the generation only if something actually changed.  (Notice that
     * what we compared to was the old state of the base path variables.)
     */
    if (pathChanged)
        activePathGeneration++;
}

References activeCreationNamespace, activePathGeneration, activeSearchPath, activeTempCreationPending, baseCreationNamespace, baseSearchPath, baseSearchPathValid, baseTempCreationPending, cachedNamespacePath(), equal(), SearchPathCacheEntry::finalPath, SearchPathCacheEntry::firstNS, GetUserId(), list_copy(), list_free(), MemoryContextSwitchTo(), namespace_search_path, namespaceUser, SearchPathCacheEntry::temp_missing, and TopMemoryContext.

Referenced by CollationGetCollid(), CollationIsVisibleExt(), ConversionGetConid(), ConversionIsVisibleExt(), fetch_search_path(), fetch_search_path_array(), FindDefaultConversionProc(), FuncnameGetCandidates(), FunctionIsVisibleExt(), 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(), GetSearchPathMatcher(), OpclassIsVisibleExt(), OpclassnameGetOpcid(), OperatorIsVisibleExt(), OpernameGetCandidates(), OpernameGetOprid(), OpfamilyIsVisibleExt(), OpfamilynameGetOpfid(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), RelationIsVisibleExt(), RelnameGetRelid(), SearchPathMatchesCurrentEnvironment(), StatisticsObjIsVisibleExt(), TSConfigIsVisibleExt(), TSDictionaryIsVisibleExt(), TSParserIsVisibleExt(), TSTemplateIsVisibleExt(), TypeIsVisibleExt(), and TypenameGetTypidExtended().

RelationIsVisible()

bool RelationIsVisible

(

Oid

relid

)

Definition at line 913 of file namespace.c.

{
    return RelationIsVisibleExt(relid, NULL);
}

References RelationIsVisibleExt().

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

RelationIsVisibleExt()

static bool RelationIsVisibleExt ( Oid  relid, bool *  is_missing  )

static

Definition at line 925 of file namespace.c.

{
    HeapTuple   reltup;
    Form_pg_class relform;
    Oid         relnamespace;
    bool        visible;
 
    reltup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
    if (!HeapTupleIsValid(reltup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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, and SearchSysCache1().

Referenced by pg_table_is_visible(), and RelationIsVisible().

RelnameGetRelid()

Oid RelnameGetRelid

(

const char *

relname

)

Definition at line 885 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_wordrowtype(), and RangeVarGetRelidExtended().

RemoveTempRelations()

static void RemoveTempRelations ( Oid  tempNamespaceId )

static

Definition at line 4598 of file namespace.c.

{
    ObjectAddress object;
 
    /*
     * We want to get rid of everything in the target namespace, but not the
     * namespace itself (deleting it only to recreate it later would be a
     * waste of cycles).  Hence, specify SKIP_ORIGINAL.  It's also an INTERNAL
     * deletion, and we want to not drop any extensions that might happen to
     * own temp objects.
     */
    object.classId = NamespaceRelationId;
    object.objectId = tempNamespaceId;
    object.objectSubId = 0;
 
    performDeletion(&object, DROP_CASCADE,
                    PERFORM_DELETION_INTERNAL |
                    PERFORM_DELETION_QUIETLY |
                    PERFORM_DELETION_SKIP_ORIGINAL |
                    PERFORM_DELETION_SKIP_EXTENSIONS);
}

References ObjectAddress::classId, DROP_CASCADE, PERFORM_DELETION_INTERNAL, PERFORM_DELETION_QUIETLY, PERFORM_DELETION_SKIP_EXTENSIONS, PERFORM_DELETION_SKIP_ORIGINAL, and performDeletion().

Referenced by InitTempTableNamespace(), RemoveTempRelationsCallback(), and ResetTempTableNamespace().

RemoveTempRelationsCallback()

static void RemoveTempRelationsCallback ( int  code, Datum  arg  )

static

Definition at line 4624 of file namespace.c.

{
    if (OidIsValid(myTempNamespace))    /* should always be true */
    {
        /* Need to ensure we have a usable transaction. */
        AbortOutOfAnyTransaction();
        StartTransactionCommand();
        PushActiveSnapshot(GetTransactionSnapshot());
 
        RemoveTempRelations(myTempNamespace);
 
        PopActiveSnapshot();
        CommitTransactionCommand();
    }
}

References AbortOutOfAnyTransaction(), CommitTransactionCommand(), GetTransactionSnapshot(), myTempNamespace, OidIsValid, PopActiveSnapshot(), PushActiveSnapshot(), RemoveTempRelations(), and StartTransactionCommand().

Referenced by AtEOXact_Namespace().

ResetTempTableNamespace()

void ResetTempTableNamespace

(

void

)

Definition at line 4644 of file namespace.c.

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

References myTempNamespace, OidIsValid, and RemoveTempRelations().

Referenced by DiscardAll(), and DiscardCommand().

SearchPathMatchesCurrentEnvironment()

bool SearchPathMatchesCurrentEnvironment

(

SearchPathMatcher *

path

)

Definition at line 3911 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, SearchPathMatcher::addCatalog, SearchPathMatcher::addTemp, SearchPathMatcher::generation, InvalidOid, lfirst_oid, list_head(), lnext(), myTempNamespace, recomputeNamespacePath(), and SearchPathMatcher::schemas.

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

SetTempNamespaceState()

void SetTempNamespaceState	(	Oid	tempNamespaceId,
		Oid	tempToastNamespaceId
	)

Definition at line 3821 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 */
    searchPathCacheValid = false;
}

References Assert, baseSearchPathValid, InvalidOid, InvalidSubTransactionId, myTempNamespace, myTempNamespaceSubID, myTempToastNamespace, and searchPathCacheValid.

Referenced by ParallelWorkerMain().

spcache_init()

static void spcache_init ( void  )

static

Definition at line 306 of file namespace.c.

{
    if (SearchPathCache && searchPathCacheValid &&
        SearchPathCache->members < SPCACHE_RESET_THRESHOLD)
        return;
 
    searchPathCacheValid = false;
    baseSearchPathValid = false;
 
    /*
     * Make sure we don't leave dangling pointers if a failure happens during
     * initialization.
     */
    SearchPathCache = NULL;
    LastSearchPathCacheEntry = NULL;
 
    if (SearchPathCacheContext == NULL)
    {
        /* Make the context we'll keep search path cache hashtable in */
        SearchPathCacheContext = AllocSetContextCreate(TopMemoryContext,
                                                       "search_path processing cache",
                                                       ALLOCSET_DEFAULT_SIZES);
    }
    else
    {
        MemoryContextReset(SearchPathCacheContext);
    }
 
    /* arbitrary initial starting size of 16 elements */
    SearchPathCache = nsphash_create(SearchPathCacheContext, 16, NULL);
    searchPathCacheValid = true;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, baseSearchPathValid, LastSearchPathCacheEntry, MemoryContextReset(), SearchPathCache, SearchPathCacheContext, searchPathCacheValid, SPCACHE_RESET_THRESHOLD, and TopMemoryContext.

Referenced by cachedNamespacePath(), and check_search_path().

spcache_insert()

static SearchPathCacheEntry* spcache_insert ( const char *  searchPath, Oid  roleid  )

static

Definition at line 374 of file namespace.c.

{
    if (LastSearchPathCacheEntry &&
        LastSearchPathCacheEntry->key.roleid == roleid &&
        strcmp(LastSearchPathCacheEntry->key.searchPath, searchPath) == 0)
    {
        return LastSearchPathCacheEntry;
    }
    else
    {
        SearchPathCacheEntry *entry;
        SearchPathCacheKey cachekey = {
            .searchPath = searchPath,
            .roleid = roleid
        };
 
        /*
         * searchPath is not saved in SearchPathCacheContext. First perform a
         * lookup, and copy searchPath only if we need to create a new entry.
         */
        entry = nsphash_lookup(SearchPathCache, cachekey);
 
        if (!entry)
        {
            bool        found;
 
            cachekey.searchPath = MemoryContextStrdup(SearchPathCacheContext, searchPath);
            entry = nsphash_insert(SearchPathCache, cachekey, &found);
            Assert(!found);
 
            entry->oidlist = NIL;
            entry->finalPath = NIL;
            entry->firstNS = InvalidOid;
            entry->temp_missing = false;
            entry->forceRecompute = false;
            /* do not touch entry->status, used by simplehash */
        }
 
        LastSearchPathCacheEntry = entry;
        return entry;
    }
}

References Assert, SearchPathCacheEntry::finalPath, SearchPathCacheEntry::firstNS, SearchPathCacheEntry::forceRecompute, InvalidOid, SearchPathCacheEntry::key, LastSearchPathCacheEntry, MemoryContextStrdup(), NIL, SearchPathCacheEntry::oidlist, SearchPathCacheKey::roleid, SearchPathCacheKey::searchPath, SearchPathCache, SearchPathCacheContext, and SearchPathCacheEntry::temp_missing.

Referenced by cachedNamespacePath(), and check_search_path().

spcache_lookup()

static SearchPathCacheEntry* spcache_lookup ( const char *  searchPath, Oid  roleid  )

static

Definition at line 344 of file namespace.c.

{
    if (LastSearchPathCacheEntry &&
        LastSearchPathCacheEntry->key.roleid == roleid &&
        strcmp(LastSearchPathCacheEntry->key.searchPath, searchPath) == 0)
    {
        return LastSearchPathCacheEntry;
    }
    else
    {
        SearchPathCacheEntry *entry;
        SearchPathCacheKey cachekey = {
            .searchPath = searchPath,
            .roleid = roleid
        };
 
        entry = nsphash_lookup(SearchPathCache, cachekey);
        if (entry)
            LastSearchPathCacheEntry = entry;
        return entry;
    }
}

References SearchPathCacheEntry::key, LastSearchPathCacheEntry, SearchPathCacheKey::roleid, SearchPathCacheKey::searchPath, and SearchPathCache.

Referenced by check_search_path().

spcachekey_equal()

static bool spcachekey_equal ( SearchPathCacheKey  a, SearchPathCacheKey  b  )

inlinestatic

Definition at line 274 of file namespace.c.

{
    return a.roleid == b.roleid &&
        strcmp(a.searchPath, b.searchPath) == 0;
}

References a, and b.

spcachekey_hash()

static uint32 spcachekey_hash ( SearchPathCacheKey  key )

inlinestatic

Definition at line 254 of file namespace.c.

{
    fasthash_state hs;
    int         sp_len;
 
    fasthash_init(&hs, 0);
 
    hs.accum = key.roleid;
    fasthash_combine(&hs);
 
    /*
     * Combine search path into the hash and save the length for tweaking the
     * final mix.
     */
    sp_len = fasthash_accum_cstring(&hs, key.searchPath);
 
    return fasthash_final32(&hs, sp_len);
}

References fasthash_state::accum, fasthash_accum_cstring(), fasthash_combine(), fasthash_final32(), fasthash_init(), and sort-test::key.

StatisticsObjIsVisible()

bool StatisticsObjIsVisible

(

Oid

stxid

)

Definition at line 2632 of file namespace.c.

{
    return StatisticsObjIsVisibleExt(stxid, NULL);
}

References StatisticsObjIsVisibleExt().

Referenced by getObjectDescription().

StatisticsObjIsVisibleExt()

static bool StatisticsObjIsVisibleExt ( Oid  stxid, bool *  is_missing  )

static

Definition at line 2644 of file namespace.c.

{
    HeapTuple   stxtup;
    Form_pg_statistic_ext stxform;
    Oid         stxnamespace;
    bool        visible;
 
    stxtup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(stxid));
    if (!HeapTupleIsValid(stxtup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        elog(ERROR, "cache lookup failed for statistics object %u", stxid);
    }
    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(), and SearchSysCacheExists2.

Referenced by pg_statistics_obj_is_visible(), and StatisticsObjIsVisible().

TSConfigIsVisible()

bool TSConfigIsVisible

(

Oid

cfgid

)

Definition at line 3210 of file namespace.c.

{
    return TSConfigIsVisibleExt(cfgid, NULL);
}

References TSConfigIsVisibleExt().

Referenced by getObjectDescription(), and regconfigout().

TSConfigIsVisibleExt()

static bool TSConfigIsVisibleExt ( Oid  cfgid, bool *  is_missing  )

static

Definition at line 3222 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_config form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgid));
    if (!HeapTupleIsValid(tup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), and SearchSysCacheExists2.

Referenced by pg_ts_config_is_visible(), and TSConfigIsVisible().

TSDictionaryIsVisible()

bool TSDictionaryIsVisible

(

Oid

dictId

)

Definition at line 2919 of file namespace.c.

{
    return TSDictionaryIsVisibleExt(dictId, NULL);
}

References TSDictionaryIsVisibleExt().

Referenced by getObjectDescription(), and regdictionaryout().

TSDictionaryIsVisibleExt()

static bool TSDictionaryIsVisibleExt ( Oid  dictId, bool *  is_missing  )

static

Definition at line 2931 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_dict form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));
    if (!HeapTupleIsValid(tup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), and SearchSysCacheExists2.

Referenced by pg_ts_dict_is_visible(), and TSDictionaryIsVisible().

TSParserIsVisible()

bool TSParserIsVisible

(

Oid

prsId

)

Definition at line 2774 of file namespace.c.

{
    return TSParserIsVisibleExt(prsId, NULL);
}

References TSParserIsVisibleExt().

Referenced by getObjectDescription().

TSParserIsVisibleExt()

static bool TSParserIsVisibleExt ( Oid  prsId, bool *  is_missing  )

static

Definition at line 2786 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_parser form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(prsId));
    if (!HeapTupleIsValid(tup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), and SearchSysCacheExists2.

Referenced by pg_ts_parser_is_visible(), and TSParserIsVisible().

TSTemplateIsVisible()

bool TSTemplateIsVisible

(

Oid

tmplId

)

Definition at line 3065 of file namespace.c.

{
    return TSTemplateIsVisibleExt(tmplId, NULL);
}

References TSTemplateIsVisibleExt().

Referenced by getObjectDescription().

TSTemplateIsVisibleExt()

static bool TSTemplateIsVisibleExt ( Oid  tmplId, bool *  is_missing  )

static

Definition at line 3077 of file namespace.c.

{
    HeapTuple   tup;
    Form_pg_ts_template form;
    Oid         namespace;
    bool        visible;
 
    tup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(tmplId));
    if (!HeapTupleIsValid(tup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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(), and SearchSysCacheExists2.

Referenced by pg_ts_template_is_visible(), and TSTemplateIsVisible().

TypeIsVisible()

bool TypeIsVisible

(

Oid

typid

)

Definition at line 1040 of file namespace.c.

{
    return TypeIsVisibleExt(typid, NULL);
}

References TypeIsVisibleExt().

Referenced by format_type_extended().

TypeIsVisibleExt()

static bool TypeIsVisibleExt ( Oid  typid, bool *  is_missing  )

static

Definition at line 1052 of file namespace.c.

{
    HeapTuple   typtup;
    Form_pg_type typform;
    Oid         typnamespace;
    bool        visible;
 
    typtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
    if (!HeapTupleIsValid(typtup))
    {
        if (is_missing != NULL)
        {
            *is_missing = true;
            return false;
        }
        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, and typname.

Referenced by pg_type_is_visible(), and TypeIsVisible().

TypenameGetTypid()

Oid TypenameGetTypid

(

const char *

typname

)

Definition at line 995 of file namespace.c.

{
    return TypenameGetTypidExtended(typname, true);
}

References TypenameGetTypidExtended(), and typname.

TypenameGetTypidExtended()

Oid TypenameGetTypidExtended	(	const char *	typname,
		bool	temp_ok
	)

Definition at line 1008 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(), and typname.

Referenced by LookupTypeNameExtended(), and TypenameGetTypid().

Variable Documentation

activeCreationNamespace

Oid activeCreationNamespace = InvalidOid

static

Definition at line 139 of file namespace.c.

Referenced by fetch_search_path(), GetSearchPathMatcher(), InitializeSearchPath(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), recomputeNamespacePath(), and SearchPathMatchesCurrentEnvironment().

activePathGeneration

uint64 activePathGeneration = 1

static

Definition at line 145 of file namespace.c.

Referenced by GetSearchPathMatcher(), InitializeSearchPath(), recomputeNamespacePath(), and SearchPathMatchesCurrentEnvironment().

activeSearchPath

List* activeSearchPath = NIL

static

Definition at line 136 of file namespace.c.

Referenced by CollationGetCollid(), CollationIsVisibleExt(), ConversionGetConid(), ConversionIsVisibleExt(), fetch_search_path(), fetch_search_path_array(), FindDefaultConversionProc(), FuncnameGetCandidates(), FunctionIsVisibleExt(), 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(), GetSearchPathMatcher(), InitializeSearchPath(), OpclassIsVisibleExt(), OpclassnameGetOpcid(), OperatorIsVisibleExt(), OpernameGetCandidates(), OpernameGetOprid(), OpfamilyIsVisibleExt(), OpfamilynameGetOpfid(), recomputeNamespacePath(), RelationIsVisibleExt(), RelnameGetRelid(), SearchPathMatchesCurrentEnvironment(), StatisticsObjIsVisibleExt(), TSConfigIsVisibleExt(), TSDictionaryIsVisibleExt(), TSParserIsVisibleExt(), TSTemplateIsVisibleExt(), TypeIsVisibleExt(), and TypenameGetTypidExtended().

activeTempCreationPending

bool activeTempCreationPending = false

static

Definition at line 142 of file namespace.c.

Referenced by fetch_search_path(), InitializeSearchPath(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), and recomputeNamespacePath().

baseCreationNamespace

Oid baseCreationNamespace = InvalidOid

static

Definition at line 151 of file namespace.c.

Referenced by InitializeSearchPath(), and recomputeNamespacePath().

baseSearchPath

List* baseSearchPath = NIL

static

Definition at line 149 of file namespace.c.

Referenced by InitializeSearchPath(), and recomputeNamespacePath().

baseSearchPathValid

bool baseSearchPathValid = true

static

Definition at line 158 of file namespace.c.

Referenced by assign_search_path(), AtEOSubXact_Namespace(), AtEOXact_Namespace(), InitializeSearchPath(), InitTempTableNamespace(), InvalidationCallback(), recomputeNamespacePath(), SetTempNamespaceState(), and spcache_init().

baseTempCreationPending

bool baseTempCreationPending = false

static

Definition at line 153 of file namespace.c.

Referenced by InitializeSearchPath(), and recomputeNamespacePath().

LastSearchPathCacheEntry

SearchPathCacheEntry* LastSearchPathCacheEntry = NULL

static

Definition at line 300 of file namespace.c.

Referenced by spcache_init(), spcache_insert(), and spcache_lookup().

myTempNamespace

Oid myTempNamespace = InvalidOid

static

Definition at line 201 of file namespace.c.

Referenced by AccessTempTableNamespace(), AtEOSubXact_Namespace(), AtEOXact_Namespace(), CollationGetCollid(), ConversionGetConid(), fetch_search_path_array(), finalNamespacePath(), FindDefaultConversionProc(), 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(), GetSearchPathMatcher(), GetTempNamespaceState(), InitTempTableNamespace(), isTempNamespace(), isTempOrTempToastNamespace(), LookupCreationNamespace(), LookupExplicitNamespace(), LookupNamespaceNoError(), OpclassnameGetOpcid(), OpernameGetCandidates(), OpernameGetOprid(), OpfamilynameGetOpfid(), pg_my_temp_schema(), preprocessNamespacePath(), QualifiedNameGetCreationNamespace(), RangeVarGetCreationNamespace(), RangeVarGetRelidExtended(), RemoveTempRelationsCallback(), ResetTempTableNamespace(), SearchPathMatchesCurrentEnvironment(), SetTempNamespaceState(), TSConfigIsVisibleExt(), TSDictionaryIsVisibleExt(), TSParserIsVisibleExt(), TSTemplateIsVisibleExt(), and TypenameGetTypidExtended().

myTempNamespaceSubID

SubTransactionId myTempNamespaceSubID = InvalidSubTransactionId

static

Definition at line 205 of file namespace.c.

Referenced by AtEOSubXact_Namespace(), AtEOXact_Namespace(), InitTempTableNamespace(), and SetTempNamespaceState().

myTempToastNamespace

Oid myTempToastNamespace = InvalidOid

static

Definition at line 203 of file namespace.c.

Referenced by AtEOSubXact_Namespace(), AtEOXact_Namespace(), GetTempNamespaceState(), GetTempToastNamespace(), InitTempTableNamespace(), isTempOrTempToastNamespace(), isTempToastNamespace(), and SetTempNamespaceState().

namespace_search_path

char* namespace_search_path = NULL

Definition at line 211 of file namespace.c.

Referenced by CreateSchemaCommand(), and recomputeNamespacePath().

namespaceUser

Oid namespaceUser = InvalidOid

static

Definition at line 155 of file namespace.c.

Referenced by InitializeSearchPath(), and recomputeNamespacePath().

SearchPathCache

nsphash_hash* SearchPathCache = NULL

static

Definition at line 299 of file namespace.c.

Referenced by spcache_init(), spcache_insert(), and spcache_lookup().

SearchPathCacheContext

MemoryContext SearchPathCacheContext = NULL

static

Definition at line 165 of file namespace.c.

Referenced by cachedNamespacePath(), check_search_path(), spcache_init(), and spcache_insert().

searchPathCacheValid

bool searchPathCacheValid = false

static

Definition at line 164 of file namespace.c.

Referenced by AtEOSubXact_Namespace(), AtEOXact_Namespace(), InitializeSearchPath(), InitTempTableNamespace(), InvalidationCallback(), SetTempNamespaceState(), and spcache_init().