1 /*-------------------------------------------------------------------------
4 * code to support accessing and searching namespaces
6 * This is separate from pg_namespace.c, which contains the routines that
7 * directly manipulate the pg_namespace system catalog. This module
8 * provides routines associated with defining a "namespace search path"
9 * and implementing search-path-controlled searches.
12 * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
13 * Portions Copyright (c) 1994, Regents of the University of California
16 * $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.37 2002/11/02 02:33:03 tgl Exp $
18 *-------------------------------------------------------------------------
22 #include "access/heapam.h"
23 #include "access/xact.h"
24 #include "catalog/catalog.h"
25 #include "catalog/catname.h"
26 #include "catalog/dependency.h"
27 #include "catalog/heap.h"
28 #include "catalog/namespace.h"
29 #include "catalog/pg_conversion.h"
30 #include "catalog/pg_inherits.h"
31 #include "catalog/pg_namespace.h"
32 #include "catalog/pg_opclass.h"
33 #include "catalog/pg_operator.h"
34 #include "catalog/pg_proc.h"
35 #include "catalog/pg_shadow.h"
36 #include "catalog/pg_type.h"
37 #include "lib/stringinfo.h"
38 #include "miscadmin.h"
39 #include "nodes/makefuncs.h"
40 #include "storage/backendid.h"
41 #include "storage/ipc.h"
42 #include "utils/acl.h"
43 #include "utils/builtins.h"
44 #include "utils/catcache.h"
45 #include "utils/fmgroids.h"
46 #include "utils/guc.h"
47 #include "utils/inval.h"
48 #include "utils/lsyscache.h"
49 #include "utils/syscache.h"
53 * The namespace search path is a possibly-empty list of namespace OIDs.
54 * In addition to the explicit list, several implicitly-searched namespaces
57 * 1. If a "special" namespace has been set by PushSpecialNamespace, it is
58 * always searched first. (This is a hack for CREATE SCHEMA.)
60 * 2. If a TEMP table namespace has been initialized in this session, it
61 * is always searched just after any special namespace.
63 * 3. The system catalog namespace is always searched. If the system
64 * namespace is present in the explicit path then it will be searched in
65 * the specified order; otherwise it will be searched after TEMP tables and
66 * *before* the explicit list. (It might seem that the system namespace
67 * should be implicitly last, but this behavior appears to be required by
68 * SQL99. Also, this provides a way to search the system namespace first
69 * without thereby making it the default creation target namespace.)
71 * The default creation target namespace is normally equal to the first
72 * element of the explicit list, but is the "special" namespace when one
73 * has been set. If the explicit list is empty and there is no special
74 * namespace, there is no default target.
76 * In bootstrap mode, the search path is set equal to 'pg_catalog', so that
77 * the system namespace is the only one searched or inserted into.
78 * The initdb script is also careful to set search_path to 'pg_catalog' for
79 * its post-bootstrap standalone backend runs. Otherwise the default search
80 * path is determined by GUC. The factory default path contains the PUBLIC
81 * namespace (if it exists), preceded by the user's personal namespace
84 * If namespaceSearchPathValid is false, then namespaceSearchPath (and other
85 * derived variables) need to be recomputed from namespace_search_path.
86 * We mark it invalid upon an assignment to namespace_search_path or receipt
87 * of a syscache invalidation event for pg_namespace. The recomputation
88 * is done during the next lookup attempt.
90 * Any namespaces mentioned in namespace_search_path that are not readable
91 * by the current user ID are simply left out of namespaceSearchPath; so
92 * we have to be willing to recompute the path when current userid changes.
93 * namespaceUser is the userid the path has been computed for.
96 static List *namespaceSearchPath = NIL;
98 static Oid namespaceUser = InvalidOid;
100 /* default place to create stuff; if InvalidOid, no default */
101 static Oid defaultCreationNamespace = InvalidOid;
103 /* first explicit member of list; usually same as defaultCreationNamespace */
104 static Oid firstExplicitNamespace = InvalidOid;
106 /* The above four values are valid only if namespaceSearchPathValid */
107 static bool namespaceSearchPathValid = true;
110 * myTempNamespace is InvalidOid until and unless a TEMP namespace is set up
111 * in a particular backend session (this happens when a CREATE TEMP TABLE
112 * command is first executed). Thereafter it's the OID of the temp namespace.
113 * firstTempTransaction flags whether we've committed creation of the TEMP
116 static Oid myTempNamespace = InvalidOid;
118 static bool firstTempTransaction = false;
121 * "Special" namespace for CREATE SCHEMA. If set, it's the first search
122 * path element, and also the default creation namespace.
124 static Oid mySpecialNamespace = InvalidOid;
127 * This is the text equivalent of the search path --- it's the value
128 * of the GUC variable 'search_path'.
130 char *namespace_search_path = NULL;
133 /* Local functions */
134 static void recomputeNamespacePath(void);
135 static void InitTempTableNamespace(void);
136 static void RemoveTempRelations(Oid tempNamespaceId);
137 static void RemoveTempRelationsCallback(void);
138 static void NamespaceCallback(Datum arg, Oid relid);
140 /* These don't really need to appear in any header file */
141 Datum pg_table_is_visible(PG_FUNCTION_ARGS);
142 Datum pg_type_is_visible(PG_FUNCTION_ARGS);
143 Datum pg_function_is_visible(PG_FUNCTION_ARGS);
144 Datum pg_operator_is_visible(PG_FUNCTION_ARGS);
145 Datum pg_opclass_is_visible(PG_FUNCTION_ARGS);
150 * Given a RangeVar describing an existing relation,
151 * select the proper namespace and look up the relation OID.
153 * If the relation is not found, return InvalidOid if failOK = true,
154 * otherwise raise an error.
157 RangeVarGetRelid(const RangeVar *relation, bool failOK)
163 * We check the catalog name and then ignore it.
165 if (relation->catalogname)
167 if (strcmp(relation->catalogname, DatabaseName) != 0)
168 elog(ERROR, "Cross-database references are not implemented");
171 if (relation->schemaname)
173 /* use exact schema given */
174 namespaceId = LookupExplicitNamespace(relation->schemaname);
175 relId = get_relname_relid(relation->relname, namespaceId);
179 /* search the namespace path */
180 relId = RelnameGetRelid(relation->relname);
183 if (!OidIsValid(relId) && !failOK)
185 if (relation->schemaname)
186 elog(ERROR, "Relation \"%s\".\"%s\" does not exist",
187 relation->schemaname, relation->relname);
189 elog(ERROR, "Relation \"%s\" does not exist",
196 * RangeVarGetCreationNamespace
197 * Given a RangeVar describing a to-be-created relation,
198 * choose which namespace to create it in.
200 * Note: calling this may result in a CommandCounterIncrement operation.
201 * That will happen on the first request for a temp table in any particular
202 * backend run; we will need to either create or clean out the temp schema.
205 RangeVarGetCreationNamespace(const RangeVar *newRelation)
210 * We check the catalog name and then ignore it.
212 if (newRelation->catalogname)
214 if (strcmp(newRelation->catalogname, DatabaseName) != 0)
215 elog(ERROR, "Cross-database references are not implemented");
218 if (newRelation->istemp)
220 /* TEMP tables are created in our backend-local temp namespace */
221 if (newRelation->schemaname)
222 elog(ERROR, "TEMP tables may not specify a namespace");
223 /* Initialize temp namespace if first time through */
224 if (!OidIsValid(myTempNamespace))
225 InitTempTableNamespace();
226 return myTempNamespace;
229 if (newRelation->schemaname)
231 /* use exact schema given */
232 namespaceId = GetSysCacheOid(NAMESPACENAME,
233 CStringGetDatum(newRelation->schemaname),
235 if (!OidIsValid(namespaceId))
236 elog(ERROR, "Namespace \"%s\" does not exist",
237 newRelation->schemaname);
238 /* we do not check for USAGE rights here! */
242 /* use the default creation namespace */
243 recomputeNamespacePath();
244 namespaceId = defaultCreationNamespace;
245 if (!OidIsValid(namespaceId))
246 elog(ERROR, "No namespace has been selected to create in");
249 /* Note: callers will check for CREATE rights when appropriate */
256 * Try to resolve an unqualified relation name.
257 * Returns OID if relation found in search path, else InvalidOid.
260 RelnameGetRelid(const char *relname)
265 recomputeNamespacePath();
267 foreach(lptr, namespaceSearchPath)
269 Oid namespaceId = (Oid) lfirsti(lptr);
271 relid = get_relname_relid(relname, namespaceId);
272 if (OidIsValid(relid))
276 /* Not found in path */
282 * Determine whether a relation (identified by OID) is visible in the
283 * current search path. Visible means "would be found by searching
284 * for the unqualified relation name".
287 RelationIsVisible(Oid relid)
290 Form_pg_class relform;
294 reltup = SearchSysCache(RELOID,
295 ObjectIdGetDatum(relid),
297 if (!HeapTupleIsValid(reltup))
298 elog(ERROR, "Cache lookup failed for relation %u", relid);
299 relform = (Form_pg_class) GETSTRUCT(reltup);
301 recomputeNamespacePath();
304 * Quick check: if it ain't in the path at all, it ain't visible.
305 * Items in the system namespace are surely in the path and so we
306 * needn't even do intMember() for them.
308 relnamespace = relform->relnamespace;
309 if (relnamespace != PG_CATALOG_NAMESPACE &&
310 !intMember(relnamespace, namespaceSearchPath))
315 * If it is in the path, it might still not be visible; it could
316 * be hidden by another relation of the same name earlier in the
317 * path. So we must do a slow check to see if this rel would be
318 * found by RelnameGetRelid.
320 char *relname = NameStr(relform->relname);
322 visible = (RelnameGetRelid(relname) == relid);
325 ReleaseSysCache(reltup);
333 * Try to resolve an unqualified datatype name.
334 * Returns OID if type found in search path, else InvalidOid.
336 * This is essentially the same as RelnameGetRelid.
339 TypenameGetTypid(const char *typname)
344 recomputeNamespacePath();
346 foreach(lptr, namespaceSearchPath)
348 Oid namespaceId = (Oid) lfirsti(lptr);
350 typid = GetSysCacheOid(TYPENAMENSP,
351 PointerGetDatum(typname),
352 ObjectIdGetDatum(namespaceId),
354 if (OidIsValid(typid))
358 /* Not found in path */
364 * Determine whether a type (identified by OID) is visible in the
365 * current search path. Visible means "would be found by searching
366 * for the unqualified type name".
369 TypeIsVisible(Oid typid)
372 Form_pg_type typform;
376 typtup = SearchSysCache(TYPEOID,
377 ObjectIdGetDatum(typid),
379 if (!HeapTupleIsValid(typtup))
380 elog(ERROR, "Cache lookup failed for type %u", typid);
381 typform = (Form_pg_type) GETSTRUCT(typtup);
383 recomputeNamespacePath();
386 * Quick check: if it ain't in the path at all, it ain't visible.
387 * Items in the system namespace are surely in the path and so we
388 * needn't even do intMember() for them.
390 typnamespace = typform->typnamespace;
391 if (typnamespace != PG_CATALOG_NAMESPACE &&
392 !intMember(typnamespace, namespaceSearchPath))
397 * If it is in the path, it might still not be visible; it could
398 * be hidden by another type of the same name earlier in the path.
399 * So we must do a slow check to see if this type would be found
400 * by TypenameGetTypid.
402 char *typname = NameStr(typform->typname);
404 visible = (TypenameGetTypid(typname) == typid);
407 ReleaseSysCache(typtup);
414 * FuncnameGetCandidates
415 * Given a possibly-qualified function name and argument count,
416 * retrieve a list of the possible matches.
418 * If nargs is -1, we return all functions matching the given name,
419 * regardless of argument count.
421 * We search a single namespace if the function name is qualified, else
422 * all namespaces in the search path. The return list will never contain
423 * multiple entries with identical argument lists --- in the multiple-
424 * namespace case, we arrange for entries in earlier namespaces to mask
425 * identical entries in later namespaces.
428 FuncnameGetCandidates(List *names, int nargs)
430 FuncCandidateList resultList = NULL;
437 /* deconstruct the name list */
438 DeconstructQualifiedName(names, &schemaname, &funcname);
442 /* use exact schema given */
443 namespaceId = LookupExplicitNamespace(schemaname);
447 /* flag to indicate we need namespace search */
448 namespaceId = InvalidOid;
449 recomputeNamespacePath();
452 /* Search syscache by name and (optionally) nargs only */
454 catlist = SearchSysCacheList(PROCNAMENSP, 2,
455 CStringGetDatum(funcname),
456 Int16GetDatum(nargs),
459 catlist = SearchSysCacheList(PROCNAMENSP, 1,
460 CStringGetDatum(funcname),
463 for (i = 0; i < catlist->n_members; i++)
465 HeapTuple proctup = &catlist->members[i]->tuple;
466 Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
468 FuncCandidateList newResult;
470 nargs = procform->pronargs;
472 if (OidIsValid(namespaceId))
474 /* Consider only procs in specified namespace */
475 if (procform->pronamespace != namespaceId)
477 /* No need to check args, they must all be different */
481 /* Consider only procs that are in the search path */
484 foreach(nsp, namespaceSearchPath)
486 if (procform->pronamespace == (Oid) lfirsti(nsp))
491 continue; /* proc is not in search path */
494 * Okay, it's in the search path, but does it have the same
495 * arguments as something we already accepted? If so, keep
496 * only the one that appears earlier in the search path.
498 * If we have an ordered list from SearchSysCacheList (the normal
499 * case), then any conflicting proc must immediately adjoin
500 * this one in the list, so we only need to look at the newest
501 * result item. If we have an unordered list, we have to scan
502 * the whole result list.
506 FuncCandidateList prevResult;
508 if (catlist->ordered)
510 if (nargs == resultList->nargs &&
511 memcmp(procform->proargtypes, resultList->args,
512 nargs * sizeof(Oid)) == 0)
513 prevResult = resultList;
519 for (prevResult = resultList;
521 prevResult = prevResult->next)
523 if (nargs == prevResult->nargs &&
524 memcmp(procform->proargtypes, prevResult->args,
525 nargs * sizeof(Oid)) == 0)
531 /* We have a match with a previous result */
532 Assert(pathpos != prevResult->pathpos);
533 if (pathpos > prevResult->pathpos)
534 continue; /* keep previous result */
535 /* replace previous result */
536 prevResult->pathpos = pathpos;
537 prevResult->oid = HeapTupleGetOid(proctup);
538 continue; /* args are same, of course */
544 * Okay to add it to result list
546 newResult = (FuncCandidateList)
547 palloc(sizeof(struct _FuncCandidateList) - sizeof(Oid)
548 + nargs * sizeof(Oid));
549 newResult->pathpos = pathpos;
550 newResult->oid = HeapTupleGetOid(proctup);
551 newResult->nargs = nargs;
552 memcpy(newResult->args, procform->proargtypes, nargs * sizeof(Oid));
554 newResult->next = resultList;
555 resultList = newResult;
558 ReleaseSysCacheList(catlist);
565 * Determine whether a function (identified by OID) is visible in the
566 * current search path. Visible means "would be found by searching
567 * for the unqualified function name with exact argument matches".
570 FunctionIsVisible(Oid funcid)
573 Form_pg_proc procform;
577 proctup = SearchSysCache(PROCOID,
578 ObjectIdGetDatum(funcid),
580 if (!HeapTupleIsValid(proctup))
581 elog(ERROR, "Cache lookup failed for procedure %u", funcid);
582 procform = (Form_pg_proc) GETSTRUCT(proctup);
584 recomputeNamespacePath();
587 * Quick check: if it ain't in the path at all, it ain't visible.
588 * Items in the system namespace are surely in the path and so we
589 * needn't even do intMember() for them.
591 pronamespace = procform->pronamespace;
592 if (pronamespace != PG_CATALOG_NAMESPACE &&
593 !intMember(pronamespace, namespaceSearchPath))
598 * If it is in the path, it might still not be visible; it could
599 * be hidden by another proc of the same name and arguments
600 * earlier in the path. So we must do a slow check to see if this
601 * is the same proc that would be found by FuncnameGetCandidates.
603 char *proname = NameStr(procform->proname);
604 int nargs = procform->pronargs;
605 FuncCandidateList clist;
609 clist = FuncnameGetCandidates(makeList1(makeString(proname)), nargs);
611 for (; clist; clist = clist->next)
613 if (memcmp(clist->args, procform->proargtypes,
614 nargs * sizeof(Oid)) == 0)
616 /* Found the expected entry; is it the right proc? */
617 visible = (clist->oid == funcid);
623 ReleaseSysCache(proctup);
630 * OpernameGetCandidates
631 * Given a possibly-qualified operator name and operator kind,
632 * retrieve a list of the possible matches.
634 * If oprkind is '\0', we return all operators matching the given name,
635 * regardless of arguments.
637 * We search a single namespace if the operator name is qualified, else
638 * all namespaces in the search path. The return list will never contain
639 * multiple entries with identical argument lists --- in the multiple-
640 * namespace case, we arrange for entries in earlier namespaces to mask
641 * identical entries in later namespaces.
643 * The returned items always have two args[] entries --- one or the other
644 * will be InvalidOid for a prefix or postfix oprkind. nargs is 2, too.
647 OpernameGetCandidates(List *names, char oprkind)
649 FuncCandidateList resultList = NULL;
656 /* deconstruct the name list */
657 DeconstructQualifiedName(names, &schemaname, &opername);
661 /* use exact schema given */
662 namespaceId = LookupExplicitNamespace(schemaname);
666 /* flag to indicate we need namespace search */
667 namespaceId = InvalidOid;
668 recomputeNamespacePath();
671 /* Search syscache by name only */
672 catlist = SearchSysCacheList(OPERNAMENSP, 1,
673 CStringGetDatum(opername),
676 for (i = 0; i < catlist->n_members; i++)
678 HeapTuple opertup = &catlist->members[i]->tuple;
679 Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
681 FuncCandidateList newResult;
683 /* Ignore operators of wrong kind, if specific kind requested */
684 if (oprkind && operform->oprkind != oprkind)
687 if (OidIsValid(namespaceId))
689 /* Consider only opers in specified namespace */
690 if (operform->oprnamespace != namespaceId)
692 /* No need to check args, they must all be different */
696 /* Consider only opers that are in the search path */
699 foreach(nsp, namespaceSearchPath)
701 if (operform->oprnamespace == (Oid) lfirsti(nsp))
706 continue; /* oper is not in search path */
709 * Okay, it's in the search path, but does it have the same
710 * arguments as something we already accepted? If so, keep
711 * only the one that appears earlier in the search path.
713 * If we have an ordered list from SearchSysCacheList (the normal
714 * case), then any conflicting oper must immediately adjoin
715 * this one in the list, so we only need to look at the newest
716 * result item. If we have an unordered list, we have to scan
717 * the whole result list.
721 FuncCandidateList prevResult;
723 if (catlist->ordered)
725 if (operform->oprleft == resultList->args[0] &&
726 operform->oprright == resultList->args[1])
727 prevResult = resultList;
733 for (prevResult = resultList;
735 prevResult = prevResult->next)
737 if (operform->oprleft == prevResult->args[0] &&
738 operform->oprright == prevResult->args[1])
744 /* We have a match with a previous result */
745 Assert(pathpos != prevResult->pathpos);
746 if (pathpos > prevResult->pathpos)
747 continue; /* keep previous result */
748 /* replace previous result */
749 prevResult->pathpos = pathpos;
750 prevResult->oid = HeapTupleGetOid(opertup);
751 continue; /* args are same, of course */
757 * Okay to add it to result list
759 newResult = (FuncCandidateList)
760 palloc(sizeof(struct _FuncCandidateList) + sizeof(Oid));
761 newResult->pathpos = pathpos;
762 newResult->oid = HeapTupleGetOid(opertup);
763 newResult->nargs = 2;
764 newResult->args[0] = operform->oprleft;
765 newResult->args[1] = operform->oprright;
766 newResult->next = resultList;
767 resultList = newResult;
770 ReleaseSysCacheList(catlist);
777 * Determine whether an operator (identified by OID) is visible in the
778 * current search path. Visible means "would be found by searching
779 * for the unqualified operator name with exact argument matches".
782 OperatorIsVisible(Oid oprid)
785 Form_pg_operator oprform;
789 oprtup = SearchSysCache(OPEROID,
790 ObjectIdGetDatum(oprid),
792 if (!HeapTupleIsValid(oprtup))
793 elog(ERROR, "Cache lookup failed for operator %u", oprid);
794 oprform = (Form_pg_operator) GETSTRUCT(oprtup);
796 recomputeNamespacePath();
799 * Quick check: if it ain't in the path at all, it ain't visible.
800 * Items in the system namespace are surely in the path and so we
801 * needn't even do intMember() for them.
803 oprnamespace = oprform->oprnamespace;
804 if (oprnamespace != PG_CATALOG_NAMESPACE &&
805 !intMember(oprnamespace, namespaceSearchPath))
810 * If it is in the path, it might still not be visible; it could
811 * be hidden by another operator of the same name and arguments
812 * earlier in the path. So we must do a slow check to see if this
813 * is the same operator that would be found by
814 * OpernameGetCandidates.
816 char *oprname = NameStr(oprform->oprname);
817 FuncCandidateList clist;
821 clist = OpernameGetCandidates(makeList1(makeString(oprname)),
824 for (; clist; clist = clist->next)
826 if (clist->args[0] == oprform->oprleft &&
827 clist->args[1] == oprform->oprright)
829 /* Found the expected entry; is it the right op? */
830 visible = (clist->oid == oprid);
836 ReleaseSysCache(oprtup);
843 * OpclassGetCandidates
844 * Given an index access method OID, retrieve a list of all the
845 * opclasses for that AM that are visible in the search path.
847 * NOTE: the opcname_tmp field in the returned structs should not be used
848 * by callers, because it points at syscache entries that we release at
849 * the end of this routine. If any callers needed the name information,
850 * we could pstrdup() the names ... but at present it'd be wasteful.
853 OpclassGetCandidates(Oid amid)
855 OpclassCandidateList resultList = NULL;
859 /* Search syscache by AM OID only */
860 catlist = SearchSysCacheList(CLAAMNAMENSP, 1,
861 ObjectIdGetDatum(amid),
864 recomputeNamespacePath();
866 for (i = 0; i < catlist->n_members; i++)
868 HeapTuple opctup = &catlist->members[i]->tuple;
869 Form_pg_opclass opcform = (Form_pg_opclass) GETSTRUCT(opctup);
871 OpclassCandidateList newResult;
874 /* Consider only opclasses that are in the search path */
875 foreach(nsp, namespaceSearchPath)
877 if (opcform->opcnamespace == (Oid) lfirsti(nsp))
882 continue; /* opclass is not in search path */
885 * Okay, it's in the search path, but does it have the same name
886 * as something we already accepted? If so, keep only the one
887 * that appears earlier in the search path.
889 * If we have an ordered list from SearchSysCacheList (the normal
890 * case), then any conflicting opclass must immediately adjoin
891 * this one in the list, so we only need to look at the newest
892 * result item. If we have an unordered list, we have to scan the
897 OpclassCandidateList prevResult;
899 if (catlist->ordered)
901 if (strcmp(NameStr(opcform->opcname),
902 resultList->opcname_tmp) == 0)
903 prevResult = resultList;
909 for (prevResult = resultList;
911 prevResult = prevResult->next)
913 if (strcmp(NameStr(opcform->opcname),
914 prevResult->opcname_tmp) == 0)
920 /* We have a match with a previous result */
921 Assert(pathpos != prevResult->pathpos);
922 if (pathpos > prevResult->pathpos)
923 continue; /* keep previous result */
924 /* replace previous result */
925 prevResult->opcname_tmp = NameStr(opcform->opcname);
926 prevResult->pathpos = pathpos;
927 prevResult->oid = HeapTupleGetOid(opctup);
928 prevResult->opcintype = opcform->opcintype;
929 prevResult->opcdefault = opcform->opcdefault;
930 prevResult->opckeytype = opcform->opckeytype;
936 * Okay to add it to result list
938 newResult = (OpclassCandidateList)
939 palloc(sizeof(struct _OpclassCandidateList));
940 newResult->opcname_tmp = NameStr(opcform->opcname);
941 newResult->pathpos = pathpos;
942 newResult->oid = HeapTupleGetOid(opctup);
943 newResult->opcintype = opcform->opcintype;
944 newResult->opcdefault = opcform->opcdefault;
945 newResult->opckeytype = opcform->opckeytype;
946 newResult->next = resultList;
947 resultList = newResult;
950 ReleaseSysCacheList(catlist);
956 * OpclassnameGetOpcid
957 * Try to resolve an unqualified index opclass name.
958 * Returns OID if opclass found in search path, else InvalidOid.
960 * This is essentially the same as TypenameGetTypid, but we have to have
961 * an extra argument for the index AM OID.
964 OpclassnameGetOpcid(Oid amid, const char *opcname)
969 recomputeNamespacePath();
971 foreach(lptr, namespaceSearchPath)
973 Oid namespaceId = (Oid) lfirsti(lptr);
975 opcid = GetSysCacheOid(CLAAMNAMENSP,
976 ObjectIdGetDatum(amid),
977 PointerGetDatum(opcname),
978 ObjectIdGetDatum(namespaceId),
980 if (OidIsValid(opcid))
984 /* Not found in path */
990 * Determine whether an opclass (identified by OID) is visible in the
991 * current search path. Visible means "would be found by searching
992 * for the unqualified opclass name".
995 OpclassIsVisible(Oid opcid)
998 Form_pg_opclass opcform;
1002 opctup = SearchSysCache(CLAOID,
1003 ObjectIdGetDatum(opcid),
1005 if (!HeapTupleIsValid(opctup))
1006 elog(ERROR, "Cache lookup failed for opclass %u", opcid);
1007 opcform = (Form_pg_opclass) GETSTRUCT(opctup);
1009 recomputeNamespacePath();
1012 * Quick check: if it ain't in the path at all, it ain't visible.
1013 * Items in the system namespace are surely in the path and so we
1014 * needn't even do intMember() for them.
1016 opcnamespace = opcform->opcnamespace;
1017 if (opcnamespace != PG_CATALOG_NAMESPACE &&
1018 !intMember(opcnamespace, namespaceSearchPath))
1023 * If it is in the path, it might still not be visible; it could
1024 * be hidden by another opclass of the same name earlier in the
1025 * path. So we must do a slow check to see if this opclass would
1026 * be found by OpclassnameGetOpcid.
1028 char *opcname = NameStr(opcform->opcname);
1030 visible = (OpclassnameGetOpcid(opcform->opcamid, opcname) == opcid);
1033 ReleaseSysCache(opctup);
1039 * DeconstructQualifiedName
1040 * Given a possibly-qualified name expressed as a list of String nodes,
1041 * extract the schema name and object name.
1043 * *nspname_p is set to NULL if there is no explicit schema name.
1046 DeconstructQualifiedName(List *names,
1051 char *schemaname = NULL;
1052 char *objname = NULL;
1054 switch (length(names))
1057 objname = strVal(lfirst(names));
1060 schemaname = strVal(lfirst(names));
1061 objname = strVal(lsecond(names));
1064 catalogname = strVal(lfirst(names));
1065 schemaname = strVal(lsecond(names));
1066 objname = strVal(lfirst(lnext(lnext(names))));
1069 * We check the catalog name and then ignore it.
1071 if (strcmp(catalogname, DatabaseName) != 0)
1072 elog(ERROR, "Cross-database references are not implemented");
1075 elog(ERROR, "Improper qualified name (too many dotted names): %s",
1076 NameListToString(names));
1080 *nspname_p = schemaname;
1081 *objname_p = objname;
1085 * LookupExplicitNamespace
1086 * Process an explicitly-specified schema name: look up the schema
1087 * and verify we have USAGE (lookup) rights in it.
1089 * Returns the namespace OID. Raises elog if any problem.
1092 LookupExplicitNamespace(const char *nspname)
1095 AclResult aclresult;
1097 namespaceId = GetSysCacheOid(NAMESPACENAME,
1098 CStringGetDatum(nspname),
1100 if (!OidIsValid(namespaceId))
1101 elog(ERROR, "Namespace \"%s\" does not exist", nspname);
1103 aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_USAGE);
1104 if (aclresult != ACLCHECK_OK)
1105 aclcheck_error(aclresult, nspname);
1111 * QualifiedNameGetCreationNamespace
1112 * Given a possibly-qualified name for an object (in List-of-Values
1113 * format), determine what namespace the object should be created in.
1114 * Also extract and return the object name (last component of list).
1116 * This is *not* used for tables. Hence, the TEMP table namespace is
1117 * never selected as the creation target.
1120 QualifiedNameGetCreationNamespace(List *names, char **objname_p)
1126 /* deconstruct the name list */
1127 DeconstructQualifiedName(names, &schemaname, &objname);
1131 /* use exact schema given */
1132 namespaceId = GetSysCacheOid(NAMESPACENAME,
1133 CStringGetDatum(schemaname),
1135 if (!OidIsValid(namespaceId))
1136 elog(ERROR, "Namespace \"%s\" does not exist",
1138 /* we do not check for USAGE rights here! */
1142 /* use the default creation namespace */
1143 recomputeNamespacePath();
1144 namespaceId = defaultCreationNamespace;
1145 if (!OidIsValid(namespaceId))
1146 elog(ERROR, "No namespace has been selected to create in");
1149 /* Note: callers will check for CREATE rights when appropriate */
1151 *objname_p = objname;
1156 * makeRangeVarFromNameList
1157 * Utility routine to convert a qualified-name list into RangeVar form.
1160 makeRangeVarFromNameList(List *names)
1162 RangeVar *rel = makeRangeVar(NULL, NULL);
1164 switch (length(names))
1167 rel->relname = strVal(lfirst(names));
1170 rel->schemaname = strVal(lfirst(names));
1171 rel->relname = strVal(lsecond(names));
1174 rel->catalogname = strVal(lfirst(names));
1175 rel->schemaname = strVal(lsecond(names));
1176 rel->relname = strVal(lfirst(lnext(lnext(names))));
1179 elog(ERROR, "Improper relation name (too many dotted names)");
1188 * Utility routine to convert a qualified-name list into a string.
1189 * Used primarily to form error messages.
1192 NameListToString(List *names)
1194 StringInfoData string;
1197 initStringInfo(&string);
1202 appendStringInfoChar(&string, '.');
1203 appendStringInfo(&string, "%s", strVal(lfirst(l)));
1210 * isTempNamespace - is the given namespace my temporary-table namespace?
1213 isTempNamespace(Oid namespaceId)
1215 if (OidIsValid(myTempNamespace) && myTempNamespace == namespaceId)
1221 * isOtherTempNamespace - is the given namespace some other backend's
1222 * temporary-table namespace?
1225 isOtherTempNamespace(Oid namespaceId)
1230 /* If it's my own temp namespace, say "false" */
1231 if (isTempNamespace(namespaceId))
1233 /* Else, if the namespace name starts with "pg_temp_", say "true" */
1234 nspname = get_namespace_name(namespaceId);
1236 return false; /* no such namespace? */
1237 result = (strncmp(nspname, "pg_temp_", 8) == 0);
1243 * PushSpecialNamespace - push a "special" namespace onto the front of the
1246 * This is a slightly messy hack intended only for support of CREATE SCHEMA.
1247 * Although the API is defined to allow a stack of pushed namespaces, we
1248 * presently only support one at a time.
1250 * The pushed namespace will be removed from the search path at end of
1251 * transaction, whether commit or abort.
1254 PushSpecialNamespace(Oid namespaceId)
1256 Assert(!OidIsValid(mySpecialNamespace));
1257 mySpecialNamespace = namespaceId;
1258 namespaceSearchPathValid = false;
1262 * PopSpecialNamespace - remove previously pushed special namespace.
1265 PopSpecialNamespace(Oid namespaceId)
1267 Assert(mySpecialNamespace == namespaceId);
1268 mySpecialNamespace = InvalidOid;
1269 namespaceSearchPathValid = false;
1273 * FindConversionByName - find a conversion by possibly qualified name
1276 FindConversionByName(List *name)
1279 char *conversion_name;
1284 /* deconstruct the name list */
1285 DeconstructQualifiedName(name, &schemaname, &conversion_name);
1289 /* use exact schema given */
1290 namespaceId = LookupExplicitNamespace(schemaname);
1291 return FindConversion(conversion_name, namespaceId);
1295 /* search for it in search path */
1296 recomputeNamespacePath();
1298 foreach(lptr, namespaceSearchPath)
1300 namespaceId = (Oid) lfirsti(lptr);
1301 conoid = FindConversion(conversion_name, namespaceId);
1302 if (OidIsValid(conoid))
1307 /* Not found in path */
1312 * FindDefaultConversionProc - find default encoding conversion proc
1315 FindDefaultConversionProc(int4 for_encoding, int4 to_encoding)
1320 recomputeNamespacePath();
1322 foreach(lptr, namespaceSearchPath)
1324 Oid namespaceId = (Oid) lfirsti(lptr);
1326 proc = FindDefaultConversion(namespaceId, for_encoding, to_encoding);
1327 if (OidIsValid(proc))
1331 /* Not found in path */
1336 * recomputeNamespacePath - recompute path derived variables if needed.
1339 recomputeNamespacePath(void)
1341 Oid userId = GetUserId();
1348 MemoryContext oldcxt;
1351 * Do nothing if path is already valid.
1353 if (namespaceSearchPathValid && namespaceUser == userId)
1356 /* Need a modifiable copy of namespace_search_path string */
1357 rawname = pstrdup(namespace_search_path);
1359 /* Parse string into list of identifiers */
1360 if (!SplitIdentifierString(rawname, ',', &namelist))
1362 /* syntax error in name list */
1363 /* this should not happen if GUC checked check_search_path */
1364 elog(ERROR, "recomputeNamespacePath: invalid list syntax");
1368 * Convert the list of names to a list of OIDs. If any names are not
1369 * recognizable or we don't have read access, just leave them out of
1370 * the list. (We can't raise an error, since the search_path setting
1371 * has already been accepted.) Don't make duplicate entries, either.
1374 foreach(l, namelist)
1376 char *curname = (char *) lfirst(l);
1379 if (strcmp(curname, "$user") == 0)
1381 /* $user --- substitute namespace matching user name, if any */
1384 tuple = SearchSysCache(SHADOWSYSID,
1385 ObjectIdGetDatum(userId),
1387 if (HeapTupleIsValid(tuple))
1391 uname = NameStr(((Form_pg_shadow) GETSTRUCT(tuple))->usename);
1392 namespaceId = GetSysCacheOid(NAMESPACENAME,
1393 CStringGetDatum(uname),
1395 ReleaseSysCache(tuple);
1396 if (OidIsValid(namespaceId) &&
1397 !intMember(namespaceId, oidlist) &&
1398 pg_namespace_aclcheck(namespaceId, userId,
1399 ACL_USAGE) == ACLCHECK_OK)
1400 oidlist = lappendi(oidlist, namespaceId);
1405 /* normal namespace reference */
1406 namespaceId = GetSysCacheOid(NAMESPACENAME,
1407 CStringGetDatum(curname),
1409 if (OidIsValid(namespaceId) &&
1410 !intMember(namespaceId, oidlist) &&
1411 pg_namespace_aclcheck(namespaceId, userId,
1412 ACL_USAGE) == ACLCHECK_OK)
1413 oidlist = lappendi(oidlist, namespaceId);
1418 * Remember the first member of the explicit list.
1421 firstNS = InvalidOid;
1423 firstNS = (Oid) lfirsti(oidlist);
1426 * Add any implicitly-searched namespaces to the list. Note these go
1427 * on the front, not the back; also notice that we do not check USAGE
1428 * permissions for these.
1430 if (!intMember(PG_CATALOG_NAMESPACE, oidlist))
1431 oidlist = lconsi(PG_CATALOG_NAMESPACE, oidlist);
1433 if (OidIsValid(myTempNamespace) &&
1434 !intMember(myTempNamespace, oidlist))
1435 oidlist = lconsi(myTempNamespace, oidlist);
1437 if (OidIsValid(mySpecialNamespace) &&
1438 !intMember(mySpecialNamespace, oidlist))
1439 oidlist = lconsi(mySpecialNamespace, oidlist);
1442 * Now that we've successfully built the new list of namespace OIDs,
1443 * save it in permanent storage.
1445 oldcxt = MemoryContextSwitchTo(TopMemoryContext);
1446 newpath = listCopy(oidlist);
1447 MemoryContextSwitchTo(oldcxt);
1449 /* Now safe to assign to state variable. */
1450 freeList(namespaceSearchPath);
1451 namespaceSearchPath = newpath;
1454 * Update info derived from search path.
1456 firstExplicitNamespace = firstNS;
1457 if (OidIsValid(mySpecialNamespace))
1458 defaultCreationNamespace = mySpecialNamespace;
1460 defaultCreationNamespace = firstNS;
1462 /* Mark the path valid. */
1463 namespaceSearchPathValid = true;
1464 namespaceUser = userId;
1473 * InitTempTableNamespace
1474 * Initialize temp table namespace on first use in a particular backend
1477 InitTempTableNamespace(void)
1479 char namespaceName[NAMEDATALEN];
1483 * First, do permission check to see if we are authorized to make temp
1484 * tables. We use a nonstandard error message here since
1485 * "databasename: permission denied" might be a tad cryptic.
1487 * Note we apply the check to the session user, not the currently active
1488 * userid, since we are not going to change our minds about temp table
1489 * availability during the session.
1491 if (pg_database_aclcheck(MyDatabaseId, GetSessionUserId(),
1492 ACL_CREATE_TEMP) != ACLCHECK_OK)
1493 elog(ERROR, "%s: not authorized to create temp tables",
1496 snprintf(namespaceName, NAMEDATALEN, "pg_temp_%d", MyBackendId);
1498 namespaceId = GetSysCacheOid(NAMESPACENAME,
1499 CStringGetDatum(namespaceName),
1501 if (!OidIsValid(namespaceId))
1504 * First use of this temp namespace in this database; create it.
1505 * The temp namespaces are always owned by the superuser. We
1506 * leave their permissions at default --- i.e., no access except
1507 * to superuser --- to ensure that unprivileged users can't peek
1508 * at other backends' temp tables. This works because the places
1509 * that access the temp namespace for my own backend skip
1510 * permissions checks on it.
1512 namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_USESYSID);
1513 /* Advance command counter to make namespace visible */
1514 CommandCounterIncrement();
1519 * If the namespace already exists, clean it out (in case the
1520 * former owner crashed without doing so).
1522 RemoveTempRelations(namespaceId);
1526 * Okay, we've prepared the temp namespace ... but it's not committed
1527 * yet, so all our work could be undone by transaction rollback. Set
1528 * flag for AtEOXact_Namespace to know what to do.
1530 myTempNamespace = namespaceId;
1532 firstTempTransaction = true;
1534 namespaceSearchPathValid = false; /* need to rebuild list */
1538 * End-of-transaction cleanup for namespaces.
1541 AtEOXact_Namespace(bool isCommit)
1544 * If we abort the transaction in which a temp namespace was selected,
1545 * we'll have to do any creation or cleanout work over again. So,
1546 * just forget the namespace entirely until next time. On the other
1547 * hand, if we commit then register an exit callback to clean out the
1548 * temp tables at backend shutdown. (We only want to register the
1549 * callback once per session, so this is a good place to do it.)
1551 if (firstTempTransaction)
1554 on_shmem_exit(RemoveTempRelationsCallback, 0);
1557 myTempNamespace = InvalidOid;
1558 namespaceSearchPathValid = false; /* need to rebuild list */
1560 firstTempTransaction = false;
1564 * Clean up if someone failed to do PopSpecialNamespace
1566 if (OidIsValid(mySpecialNamespace))
1568 mySpecialNamespace = InvalidOid;
1569 namespaceSearchPathValid = false; /* need to rebuild list */
1574 * Remove all relations in the specified temp namespace.
1576 * This is called at backend shutdown (if we made any temp relations).
1577 * It is also called when we begin using a pre-existing temp namespace,
1578 * in order to clean out any relations that might have been created by
1579 * a crashed backend.
1582 RemoveTempRelations(Oid tempNamespaceId)
1588 ObjectAddress object;
1591 * Scan pg_class to find all the relations in the target namespace.
1592 * Ignore indexes, though, on the assumption that they'll go away when
1593 * their tables are deleted.
1595 * NOTE: if there are deletion constraints between temp relations, then
1596 * our CASCADE delete call may cause as-yet-unvisited objects to go
1597 * away. This is okay because we are using SnapshotNow; when the scan
1598 * does reach those pg_class tuples, they'll be ignored as already
1601 ScanKeyEntryInitialize(&key, 0x0,
1602 Anum_pg_class_relnamespace,
1604 ObjectIdGetDatum(tempNamespaceId));
1606 pgclass = heap_openr(RelationRelationName, AccessShareLock);
1607 scan = heap_beginscan(pgclass, SnapshotNow, 1, &key);
1609 while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
1611 switch (((Form_pg_class) GETSTRUCT(tuple))->relkind)
1613 case RELKIND_RELATION:
1614 case RELKIND_SEQUENCE:
1616 object.classId = RelOid_pg_class;
1617 object.objectId = HeapTupleGetOid(tuple);
1618 object.objectSubId = 0;
1619 performDeletion(&object, DROP_CASCADE);
1627 heap_close(pgclass, AccessShareLock);
1631 * Callback to remove temp relations at backend exit.
1634 RemoveTempRelationsCallback(void)
1636 if (OidIsValid(myTempNamespace)) /* should always be true */
1638 /* Need to ensure we have a usable transaction. */
1639 AbortOutOfAnyTransaction();
1640 StartTransactionCommand(true);
1642 RemoveTempRelations(myTempNamespace);
1644 CommitTransactionCommand(true);
1650 * Routines for handling the GUC variable 'search_path'.
1653 /* assign_hook: validate new search_path, do extra actions as needed */
1655 assign_search_path(const char *newval, bool doit, bool interactive)
1661 /* Need a modifiable copy of string */
1662 rawname = pstrdup(newval);
1664 /* Parse string into list of identifiers */
1665 if (!SplitIdentifierString(rawname, ',', &namelist))
1667 /* syntax error in name list */
1674 * If we aren't inside a transaction, we cannot do database access so
1675 * cannot verify the individual names. Must accept the list on faith.
1677 if (interactive && IsTransactionState())
1680 * Verify that all the names are either valid namespace names or
1681 * "$user". We do not require $user to correspond to a valid
1682 * namespace. We do not check for USAGE rights, either; should
1685 foreach(l, namelist)
1687 char *curname = (char *) lfirst(l);
1689 if (strcmp(curname, "$user") == 0)
1691 if (!SearchSysCacheExists(NAMESPACENAME,
1692 CStringGetDatum(curname),
1694 elog(ERROR, "Namespace \"%s\" does not exist", curname);
1702 * We mark the path as needing recomputation, but don't do anything
1703 * until it's needed. This avoids trying to do database access during
1704 * GUC initialization.
1707 namespaceSearchPathValid = false;
1713 * InitializeSearchPath: initialize module during InitPostgres.
1715 * This is called after we are up enough to be able to do catalog lookups.
1718 InitializeSearchPath(void)
1720 if (IsBootstrapProcessingMode())
1723 * In bootstrap mode, the search path must be 'pg_catalog' so that
1724 * tables are created in the proper namespace; ignore the GUC
1727 MemoryContext oldcxt;
1729 oldcxt = MemoryContextSwitchTo(TopMemoryContext);
1730 namespaceSearchPath = makeListi1(PG_CATALOG_NAMESPACE);
1731 MemoryContextSwitchTo(oldcxt);
1732 defaultCreationNamespace = PG_CATALOG_NAMESPACE;
1733 firstExplicitNamespace = PG_CATALOG_NAMESPACE;
1734 namespaceSearchPathValid = true;
1735 namespaceUser = GetUserId();
1740 * In normal mode, arrange for a callback on any syscache
1741 * invalidation of pg_namespace rows.
1743 CacheRegisterSyscacheCallback(NAMESPACEOID,
1746 /* Force search path to be recomputed on next use */
1747 namespaceSearchPathValid = false;
1753 * Syscache inval callback function
1756 NamespaceCallback(Datum arg, Oid relid)
1758 /* Force search path to be recomputed on next use */
1759 namespaceSearchPathValid = false;
1763 * Fetch the active search path, expressed as a List of OIDs.
1765 * The returned list includes the implicitly-prepended namespaces only if
1766 * includeImplicit is true.
1768 * NB: caller must treat the list as read-only!
1771 fetch_search_path(bool includeImplicit)
1775 recomputeNamespacePath();
1777 result = namespaceSearchPath;
1778 if (!includeImplicit)
1780 while (result && (Oid) lfirsti(result) != firstExplicitNamespace)
1781 result = lnext(result);
1788 * Export the FooIsVisible functions as SQL-callable functions.
1792 pg_table_is_visible(PG_FUNCTION_ARGS)
1794 Oid oid = PG_GETARG_OID(0);
1796 PG_RETURN_BOOL(RelationIsVisible(oid));
1800 pg_type_is_visible(PG_FUNCTION_ARGS)
1802 Oid oid = PG_GETARG_OID(0);
1804 PG_RETURN_BOOL(TypeIsVisible(oid));
1808 pg_function_is_visible(PG_FUNCTION_ARGS)
1810 Oid oid = PG_GETARG_OID(0);
1812 PG_RETURN_BOOL(FunctionIsVisible(oid));
1816 pg_operator_is_visible(PG_FUNCTION_ARGS)
1818 Oid oid = PG_GETARG_OID(0);
1820 PG_RETURN_BOOL(OperatorIsVisible(oid));
1824 pg_opclass_is_visible(PG_FUNCTION_ARGS)
1826 Oid oid = PG_GETARG_OID(0);
1828 PG_RETURN_BOOL(OpclassIsVisible(oid));