| blob | 30807f919047456072c8d4392e1c6581d82ef9d4 |
1 /*-------------------------------------------------------------------------
2 *
3 * namespace.c
4 * code to support accessing and searching namespaces
5 *
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.
10 *
11 *
12 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
13 * Portions Copyright (c) 1994, Regents of the University of California
14 *
15 * IDENTIFICATION
16 * src/backend/catalog/namespace.c
17 *
18 *-------------------------------------------------------------------------
19 */
65 /*
66 * The namespace search path is a possibly-empty list of namespace OIDs.
67 * In addition to the explicit list, implicitly-searched namespaces
68 * may be included:
69 *
70 * 1. If a TEMP table namespace has been initialized in this session, it
71 * is implicitly searched first.
72 *
73 * 2. The system catalog namespace is always searched. If the system
74 * namespace is present in the explicit path then it will be searched in
75 * the specified order; otherwise it will be searched after TEMP tables and
76 * *before* the explicit list. (It might seem that the system namespace
77 * should be implicitly last, but this behavior appears to be required by
78 * SQL99. Also, this provides a way to search the system namespace first
79 * without thereby making it the default creation target namespace.)
80 *
81 * For security reasons, searches using the search path will ignore the temp
82 * namespace when searching for any object type other than relations and
83 * types. (We must allow types since temp tables have rowtypes.)
84 *
85 * The default creation target namespace is always the first element of the
86 * explicit list. If the explicit list is empty, there is no default target.
87 *
88 * The textual specification of search_path can include "$user" to refer to
89 * the namespace named the same as the current user, if any. (This is just
90 * ignored if there is no such namespace.) Also, it can include "pg_temp"
91 * to refer to the current backend's temp namespace. This is usually also
92 * ignorable if the temp namespace hasn't been set up, but there's a special
93 * case: if "pg_temp" appears first then it should be the default creation
94 * target. We kluge this case a little bit so that the temp namespace isn't
95 * set up until the first attempt to create something in it. (The reason for
96 * klugery is that we can't create the temp namespace outside a transaction,
97 * but initial GUC processing of search_path happens outside a transaction.)
98 * activeTempCreationPending is true if "pg_temp" appears first in the string
99 * but is not reflected in activeCreationNamespace because the namespace isn't
100 * set up yet.
101 *
102 * In bootstrap mode, the search path is set equal to "pg_catalog", so that
103 * the system namespace is the only one searched or inserted into.
104 * initdb is also careful to set search_path to "pg_catalog" for its
105 * post-bootstrap standalone backend runs. Otherwise the default search
106 * path is determined by GUC. The factory default path contains the PUBLIC
107 * namespace (if it exists), preceded by the user's personal namespace
108 * (if one exists).
109 *
110 * activeSearchPath is always the actually active path; it points to
111 * baseSearchPath which is the list derived from namespace_search_path.
112 *
113 * If baseSearchPathValid is false, then baseSearchPath (and other derived
114 * variables) need to be recomputed from namespace_search_path, or retrieved
115 * from the search path cache if there haven't been any syscache
116 * invalidations. We mark it invalid upon an assignment to
117 * namespace_search_path or receipt of a syscache invalidation event for
118 * pg_namespace or pg_authid. The recomputation is done during the next
119 * lookup attempt.
120 *
121 * Any namespaces mentioned in namespace_search_path that are not readable
122 * by the current user ID are simply left out of baseSearchPath; so
123 * we have to be willing to recompute the path when current userid changes.
124 * namespaceUser is the userid the path has been computed for.
125 *
126 * Note: all data pointed to by these List variables is in TopMemoryContext.
127 *
128 * activePathGeneration is incremented whenever the effective values of
129 * activeSearchPath/activeCreationNamespace/activeTempCreationPending change.
130 * This can be used to quickly detect whether any change has happened since
131 * a previous examination of the search path state.
132 */
134 /* These variables define the actually active state: */
138 /* default place to create stuff; if InvalidOid, no default */
141 /* if true, activeCreationNamespace is wrong, it should be temp namespace */
144 /* current generation counter; make sure this is never zero */
147 /* These variables are the values last derived from namespace_search_path: */
157 /* The above four values are valid only if baseSearchPathValid */
160 /*
161 * Storage for search path cache. Clear searchPathCacheValid as a simple
162 * way to invalidate *all* the cache entries, not just the active one.
163 */
168 {
170 Oid roleid;
174 {
175 SearchPathCacheKey key;
182 /* needed for simplehash */
186 /*
187 * myTempNamespace is InvalidOid until and unless a TEMP namespace is set up
188 * in a particular backend session (this happens when a CREATE TEMP TABLE
189 * command is first executed). Thereafter it's the OID of the temp namespace.
190 *
191 * myTempToastNamespace is the OID of the namespace for my temp tables' toast
192 * tables. It is set when myTempNamespace is, and is InvalidOid before that.
193 *
194 * myTempNamespaceSubID shows whether we've created the TEMP namespace in the
195 * current subtransaction. The flag propagates up the subtransaction tree,
196 * so the main transaction will correctly recognize the flag if all
197 * intermediate subtransactions commit. When it is InvalidSubTransactionId,
198 * we either haven't made the TEMP namespace yet, or have successfully
199 * committed its creation, depending on whether myTempNamespace is valid.
200 */
207 /*
208 * This is the user's textual search path specification --- it's the value
209 * of the GUC variable 'search_path'.
210 */
214 /* Local functions */
238 /*
239 * Recomputing the namespace path can be costly when done frequently, such as
240 * when a function has search_path set in proconfig. Add a search path cache
241 * that can be used by recomputeNamespacePath().
242 *
243 * The cache is also used to remember already-validated strings in
244 * check_search_path() to avoid the need to call SplitIdentifierString()
245 * repeatedly.
246 *
247 * The search path cache is based on a wrapper around a simplehash hash table
248 * (nsphash, defined below). The spcache wrapper deals with OOM while trying
249 * to initialize a key, optimizes repeated lookups of the same key, and also
250 * offers a more convenient API.
251 */
255 {
256 fasthash_state hs;
264 /*
265 * Combine search path into the hash and save the length for tweaking the
266 * final mix.
267 */
271 }
275 {
278 }
280 #define SH_PREFIX nsphash
281 #define SH_ELEMENT_TYPE SearchPathCacheEntry
282 #define SH_KEY_TYPE SearchPathCacheKey
283 #define SH_KEY key
284 #define SH_HASH_KEY(tb, key) spcachekey_hash(key)
285 #define SH_EQUAL(tb, a, b) spcachekey_equal(a, b)
286 #define SH_SCOPE static inline
287 #define SH_DECLARE
288 #define SH_DEFINE
291 /*
292 * We only expect a small number of unique search_path strings to be used. If
293 * this cache grows to an unreasonable size, reset it to avoid steady-state
294 * memory growth. Most likely, only a few of those entries will benefit from
295 * the cache, and the cache will be quickly repopulated with such entries.
296 */
297 #define SPCACHE_RESET_THRESHOLD 256
302 /*
303 * Create or reset search_path cache as necessary.
304 */
305 static void
307 {
315 /*
316 * Make sure we don't leave dangling pointers if a failure happens during
317 * initialization.
318 */
323 {
324 /* Make the context we'll keep search path cache hashtable in */
327 ALLOCSET_DEFAULT_SIZES);
328 }
329 else
330 {
332 }
334 /* arbitrary initial starting size of 16 elements */
337 }
339 /*
340 * Look up entry in search path cache without inserting. Returns NULL if not
341 * present.
342 */
345 {
349 {
351 }
352 else
353 {
355 SearchPathCacheKey cachekey = {
358 };
364 }
365 }
367 /*
368 * Look up or insert entry in search path cache.
369 *
370 * Initialize key safely, so that OOM does not leave an entry without a valid
371 * key. Caller must ensure that non-key contents are properly initialized.
372 */
375 {
379 {
381 }
382 else
383 {
385 SearchPathCacheKey cachekey = {
388 };
390 /*
391 * searchPath is not saved in SearchPathCacheContext. First perform a
392 * lookup, and copy searchPath only if we need to create a new entry.
393 */
397 {
409 /* do not touch entry->status, used by simplehash */
410 }
414 }
415 }
417 /*
418 * RangeVarGetRelidExtended
419 * Given a RangeVar describing an existing relation,
420 * select the proper namespace and look up the relation OID.
421 *
422 * If the schema or relation is not found, return InvalidOid if flags contains
423 * RVR_MISSING_OK, otherwise raise an error.
424 *
425 * If flags contains RVR_NOWAIT, throw an error if we'd have to wait for a
426 * lock.
427 *
428 * If flags contains RVR_SKIP_LOCKED, return InvalidOid if we'd have to wait
429 * for a lock.
430 *
431 * flags cannot contain both RVR_NOWAIT and RVR_SKIP_LOCKED.
432 *
433 * Note that if RVR_MISSING_OK and RVR_SKIP_LOCKED are both specified, a
434 * return value of InvalidOid could either mean the relation is missing or it
435 * could not be locked.
436 *
437 * Callback allows caller to check permissions or acquire additional locks
438 * prior to grabbing the relation lock.
439 */
440 Oid
442 uint32 flags,
444 {
445 uint64 inval_count;
446 Oid relId;
451 /* verify that flags do no conflict */
454 /*
455 * We check the catalog name and then ignore it.
456 */
458 {
465 }
467 /*
468 * DDL operations can change the results of a name lookup. Since all such
469 * operations will generate invalidation messages, we keep track of
470 * whether any such messages show up while we're performing the operation,
471 * and retry until either (1) no more invalidation messages show up or (2)
472 * the answer doesn't change.
473 *
474 * But if lockmode = NoLock, then we assume that either the caller is OK
475 * with the answer changing under them, or that they already hold some
476 * appropriate lock, and therefore return the first answer we get without
477 * checking for invalidation messages. Also, if the requested lock is
478 * already held, LockRelationOid will not AcceptInvalidationMessages, so
479 * we may fail to notice a change. We could protect against that case by
480 * calling AcceptInvalidationMessages() before beginning this loop, but
481 * that would add a significant amount overhead, so for now we don't.
482 */
484 {
485 /*
486 * Remember this value, so that, after looking up the relation name
487 * and locking its OID, we can check whether any invalidation messages
488 * have been processed that might require a do-over.
489 */
492 /*
493 * Some non-default relpersistence value may have been specified. The
494 * parser never generates such a RangeVar in simple DML, but it can
495 * happen in contexts such as "CREATE TEMP TABLE foo (f1 int PRIMARY
496 * KEY)". Such a command will generate an added CREATE INDEX
497 * operation, which must be careful to find the temp table, even when
498 * pg_temp is not first in the search path.
499 */
501 {
504 else
505 {
507 {
508 Oid namespaceId;
512 /*
513 * For missing_ok, allow a non-existent schema name to
514 * return InvalidOid.
515 */
520 }
523 }
524 }
526 {
527 Oid namespaceId;
529 /* use exact schema given */
533 else
535 }
536 else
537 {
538 /* search the namespace path */
540 }
542 /*
543 * Invoke caller-supplied callback, if any.
544 *
545 * This callback is a good place to check permissions: we haven't
546 * taken the table lock yet (and it's really best to check permissions
547 * before locking anything!), but we've gotten far enough to know what
548 * OID we think we should lock. Of course, concurrent DDL might
549 * change things while we're waiting for the lock, but in that case
550 * the callback will be invoked again for the new OID.
551 */
555 /*
556 * If no lock requested, we assume the caller knows what they're
557 * doing. They should have already acquired a heavyweight lock on
558 * this relation earlier in the processing of this same statement, so
559 * it wouldn't be appropriate to AcceptInvalidationMessages() here, as
560 * that might pull the rug out from under them.
561 */
565 /*
566 * If, upon retry, we get back the same OID we did last time, then the
567 * invalidation messages we processed did not change the final answer.
568 * So we're done.
569 *
570 * If we got a different OID, we've locked the relation that used to
571 * have this name rather than the one that does now. So release the
572 * lock.
573 */
575 {
580 }
582 /*
583 * Lock relation. This will also accept any pending invalidation
584 * messages. If we got back InvalidOid, indicating not found, then
585 * there's nothing to lock, but we accept invalidation messages
586 * anyway, to flush any negative catcache entries that may be
587 * lingering.
588 */
594 {
602 else
609 }
611 /*
612 * If no invalidation message were processed, we're done!
613 */
617 /*
618 * Something may have changed. Let's repeat the name lookup, to make
619 * sure this name still references the same relation it did
620 * previously.
621 */
624 }
627 {
635 else
640 }
642 }
644 /*
645 * RangeVarGetCreationNamespace
646 * Given a RangeVar describing a to-be-created relation,
647 * choose which namespace to create it in.
648 *
649 * Note: calling this may result in a CommandCounterIncrement operation.
650 * That will happen on the first request for a temp table in any particular
651 * backend run; we will need to either create or clean out the temp schema.
652 */
653 Oid
655 {
656 Oid namespaceId;
658 /*
659 * We check the catalog name and then ignore it.
660 */
662 {
669 }
672 {
673 /* check for pg_temp alias */
675 {
676 /* Initialize temp namespace */
679 }
680 /* use exact schema given */
682 /* we do not check for USAGE rights here! */
683 }
685 {
686 /* Initialize temp namespace */
689 }
690 else
691 {
692 /* use the default creation namespace */
695 {
696 /* Need to initialize temp namespace */
699 }
705 }
707 /* Note: callers will check for CREATE rights when appropriate */
710 }
712 /*
713 * RangeVarGetAndCheckCreationNamespace
714 *
715 * This function returns the OID of the namespace in which a new relation
716 * with a given name should be created. If the user does not have CREATE
717 * permission on the target namespace, this function will instead signal
718 * an ERROR.
719 *
720 * If non-NULL, *existing_relation_id is set to the OID of any existing relation
721 * with the same name which already exists in that namespace, or to InvalidOid
722 * if no such relation exists.
723 *
724 * If lockmode != NoLock, the specified lock mode is acquired on the existing
725 * relation, if any, provided that the current user owns the target relation.
726 * However, if lockmode != NoLock and the user does not own the target
727 * relation, we throw an ERROR, as we must not try to lock relations the
728 * user does not have permissions on.
729 *
730 * As a side effect, this function acquires AccessShareLock on the target
731 * namespace. Without this, the namespace could be dropped before our
732 * transaction commits, leaving behind relations with relnamespace pointing
733 * to a no-longer-existent namespace.
734 *
735 * As a further side-effect, if the selected namespace is a temporary namespace,
736 * we mark the RangeVar as RELPERSISTENCE_TEMP.
737 */
738 Oid
740 LOCKMODE lockmode,
742 {
743 uint64 inval_count;
744 Oid relid;
746 Oid nspid;
750 /*
751 * We check the catalog name and then ignore it.
752 */
754 {
761 }
763 /*
764 * As in RangeVarGetRelidExtended(), we guard against concurrent DDL
765 * operations by tracking whether any invalidation messages are processed
766 * while we're doing the name lookups and acquiring locks. See comments
767 * in that function for a more detailed explanation of this logic.
768 */
770 {
771 AclResult aclresult;
775 /* Look up creation namespace and check for existing relation. */
780 else
783 /*
784 * In bootstrap processing mode, we don't bother with permissions or
785 * locking. Permissions might not be working yet, and locking is
786 * unnecessary.
787 */
791 /* Check namespace permissions. */
798 {
799 /* If nothing changed, we're done. */
802 /* If creation namespace has changed, give up old lock. */
805 AccessShareLock);
806 /* If name points to something different, give up old lock. */
809 }
811 /* Lock namespace. */
815 /* Lock relation, if required if and we have permission. */
817 {
823 }
825 /* If no invalidation message were processed, we're done! */
829 /* Something may have changed, so recheck our work. */
833 }
839 }
841 /*
842 * Adjust the relpersistence for an about-to-be-created relation based on the
843 * creation namespace, and throw an error for invalid combinations.
844 */
845 void
847 {
849 {
852 {
857 else
861 }
876 }
877 }
879 /*
880 * RelnameGetRelid
881 * Try to resolve an unqualified relation name.
882 * Returns OID if relation found in search path, else InvalidOid.
883 */
884 Oid
886 {
887 Oid relid;
893 {
899 }
901 /* Not found in path */
903 }
906 /*
907 * RelationIsVisible
908 * Determine whether a relation (identified by OID) is visible in the
909 * current search path. Visible means "would be found by searching
910 * for the unqualified relation name".
911 */
912 bool
914 {
916 }
918 /*
919 * RelationIsVisibleExt
920 * As above, but if the relation isn't found and is_missing is not NULL,
921 * then set *is_missing = true and return false instead of throwing
922 * an error. (Caller must initialize *is_missing = false.)
923 */
924 static bool
926 {
927 HeapTuple reltup;
928 Form_pg_class relform;
929 Oid relnamespace;
934 {
936 {
939 }
941 }
946 /*
947 * Quick check: if it ain't in the path at all, it ain't visible. Items in
948 * the system namespace are surely in the path and so we needn't even do
949 * list_member_oid() for them.
950 */
955 else
956 {
957 /*
958 * If it is in the path, it might still not be visible; it could be
959 * hidden by another relation of the same name earlier in the path. So
960 * we must do a slow check for conflicting relations.
961 */
967 {
971 {
972 /* Found it first in path */
975 }
977 {
978 /* Found something else first in path */
980 }
981 }
982 }
987 }
990 /*
991 * TypenameGetTypid
992 * Wrapper for binary compatibility.
993 */
994 Oid
996 {
998 }
1000 /*
1001 * TypenameGetTypidExtended
1002 * Try to resolve an unqualified datatype name.
1003 * Returns OID if type found in search path, else InvalidOid.
1004 *
1005 * This is essentially the same as RelnameGetRelid.
1006 */
1007 Oid
1009 {
1010 Oid typid;
1016 {
1027 }
1029 /* Not found in path */
1031 }
1033 /*
1034 * TypeIsVisible
1035 * Determine whether a type (identified by OID) is visible in the
1036 * current search path. Visible means "would be found by searching
1037 * for the unqualified type name".
1038 */
1039 bool
1041 {
1043 }
1045 /*
1046 * TypeIsVisibleExt
1047 * As above, but if the type isn't found and is_missing is not NULL,
1048 * then set *is_missing = true and return false instead of throwing
1049 * an error. (Caller must initialize *is_missing = false.)
1050 */
1051 static bool
1053 {
1054 HeapTuple typtup;
1055 Form_pg_type typform;
1056 Oid typnamespace;
1061 {
1063 {
1066 }
1068 }
1073 /*
1074 * Quick check: if it ain't in the path at all, it ain't visible. Items in
1075 * the system namespace are surely in the path and so we needn't even do
1076 * list_member_oid() for them.
1077 */
1082 else
1083 {
1084 /*
1085 * If it is in the path, it might still not be visible; it could be
1086 * hidden by another type of the same name earlier in the path. So we
1087 * must do a slow check for conflicting types.
1088 */
1094 {
1098 {
1099 /* Found it first in path */
1102 }
1106 {
1107 /* Found something else first in path */
1109 }
1110 }
1111 }
1116 }
1119 /*
1120 * FuncnameGetCandidates
1121 * Given a possibly-qualified function name and argument count,
1122 * retrieve a list of the possible matches.
1123 *
1124 * If nargs is -1, we return all functions matching the given name,
1125 * regardless of argument count. (argnames must be NIL, and expand_variadic
1126 * and expand_defaults must be false, in this case.)
1127 *
1128 * If argnames isn't NIL, we are considering a named- or mixed-notation call,
1129 * and only functions having all the listed argument names will be returned.
1130 * (We assume that length(argnames) <= nargs and all the passed-in names are
1131 * distinct.) The returned structs will include an argnumbers array showing
1132 * the actual argument index for each logical argument position.
1133 *
1134 * If expand_variadic is true, then variadic functions having the same number
1135 * or fewer arguments will be retrieved, with the variadic argument and any
1136 * additional argument positions filled with the variadic element type.
1137 * nvargs in the returned struct is set to the number of such arguments.
1138 * If expand_variadic is false, variadic arguments are not treated specially,
1139 * and the returned nvargs will always be zero.
1140 *
1141 * If expand_defaults is true, functions that could match after insertion of
1142 * default argument values will also be retrieved. In this case the returned
1143 * structs could have nargs > passed-in nargs, and ndargs is set to the number
1144 * of additional args (which can be retrieved from the function's
1145 * proargdefaults entry).
1146 *
1147 * If include_out_arguments is true, then OUT-mode arguments are considered to
1148 * be included in the argument list. Their types are included in the returned
1149 * arrays, and argnumbers are indexes in proallargtypes not proargtypes.
1150 * We also set nominalnargs to be the length of proallargtypes not proargtypes.
1151 * Otherwise OUT-mode arguments are ignored.
1152 *
1153 * It is not possible for nvargs and ndargs to both be nonzero in the same
1154 * list entry, since default insertion allows matches to functions with more
1155 * than nargs arguments while the variadic transformation requires the same
1156 * number or less.
1157 *
1158 * When argnames isn't NIL, the returned args[] type arrays are not ordered
1159 * according to the functions' declarations, but rather according to the call:
1160 * first any positional arguments, then the named arguments, then defaulted
1161 * arguments (if needed and allowed by expand_defaults). The argnumbers[]
1162 * array can be used to map this back to the catalog information.
1163 * argnumbers[k] is set to the proargtypes or proallargtypes index of the
1164 * k'th call argument.
1165 *
1166 * We search a single namespace if the function name is qualified, else
1167 * all namespaces in the search path. In the multiple-namespace case,
1168 * we arrange for entries in earlier namespaces to mask identical entries in
1169 * later namespaces.
1170 *
1171 * When expanding variadics, we arrange for non-variadic functions to mask
1172 * variadic ones if the expanded argument list is the same. It is still
1173 * possible for there to be conflicts between different variadic functions,
1174 * however.
1175 *
1176 * It is guaranteed that the return list will never contain multiple entries
1177 * with identical argument lists. When expand_defaults is true, the entries
1178 * could have more than nargs positions, but we still guarantee that they are
1179 * distinct in the first nargs positions. However, if argnames isn't NIL or
1180 * either expand_variadic or expand_defaults is true, there might be multiple
1181 * candidate functions that expand to identical argument lists. Rather than
1182 * throw error here, we report such situations by returning a single entry
1183 * with oid = 0 that represents a set of such conflicting candidates.
1184 * The caller might end up discarding such an entry anyway, but if it selects
1185 * such an entry it should react as though the call were ambiguous.
1186 *
1187 * If missing_ok is true, an empty list (NULL) is returned if the name was
1188 * schema-qualified with a schema that does not exist. Likewise if no
1189 * candidate is found for other reasons.
1190 */
1191 FuncCandidateList
1195 {
1200 Oid namespaceId;
1204 /* check for caller error */
1207 /* deconstruct the name list */
1211 {
1212 /* use exact schema given */
1216 }
1217 else
1218 {
1219 /* flag to indicate we need namespace search */
1222 }
1224 /* Search syscache by name only */
1228 {
1237 Oid va_elem_type;
1239 FuncCandidateList newResult;
1242 {
1243 /* Consider only procs in specified namespace */
1246 }
1247 else
1248 {
1249 /*
1250 * Consider only procs that are in the search path and are not in
1251 * the temp namespace.
1252 */
1256 {
1260 pathpos++;
1261 }
1264 }
1266 /*
1267 * If we are asked to match to OUT arguments, then use the
1268 * proallargtypes array (which includes those); otherwise use
1269 * proargtypes (which doesn't). Of course, if proallargtypes is null,
1270 * we always use proargtypes.
1271 */
1273 {
1274 Datum proallargtypes;
1278 Anum_pg_proc_proallargtypes,
1281 {
1292 }
1293 }
1296 {
1297 /*
1298 * Call uses named or mixed notation
1299 *
1300 * Named or mixed notation can match a variadic function only if
1301 * expand_variadic is off; otherwise there is no way to match the
1302 * presumed-nameless parameters expanded from the variadic array.
1303 */
1309 /*
1310 * Check argument count.
1311 */
1315 {
1316 /* Ignore if not enough default expressions */
1320 }
1321 else
1324 /* Ignore if it doesn't match requested argument count */
1328 /* Check for argument name match, generate positional mapping */
1334 /* Named argument matching is always "special" */
1336 }
1337 else
1338 {
1339 /*
1340 * Call uses positional notation
1341 *
1342 * Check if function is variadic, and get variadic element type if
1343 * so. If expand_variadic is false, we should just ignore
1344 * variadic-ness.
1345 */
1347 {
1351 }
1352 else
1353 {
1356 }
1358 /*
1359 * Check if function can match by using parameter defaults.
1360 */
1362 {
1363 /* Ignore if not enough default expressions */
1368 }
1369 else
1372 /* Ignore if it doesn't match requested argument count */
1375 }
1377 /*
1378 * We must compute the effective argument list so that we can easily
1379 * compare it to earlier results. We waste a palloc cycle if it gets
1380 * masked by an earlier result, but really that's a pretty infrequent
1381 * case so it's not worth worrying about.
1382 */
1393 {
1394 /* Re-order the argument types into call's logical order */
1397 }
1398 else
1399 {
1400 /* Simple positional case, just copy proargtypes as-is */
1402 }
1404 {
1406 /* Expand variadic argument into N copies of element type */
1409 }
1410 else
1414 /*
1415 * Does it have the same arguments as something we already accepted?
1416 * If so, decide what to do to avoid returning duplicate argument
1417 * lists. We can skip this check for the single-namespace case if no
1418 * special (named, variadic or defaults) match has been made, since
1419 * then the unique index on pg_proc guarantees all the matches have
1420 * different argument lists.
1421 */
1424 {
1425 /*
1426 * If we have an ordered list from SearchSysCacheList (the normal
1427 * case), then any conflicting proc must immediately adjoin this
1428 * one in the list, so we only need to look at the newest result
1429 * item. If we have an unordered list, we have to scan the whole
1430 * result list. Also, if either the current candidate or any
1431 * previous candidate is a special match, we can't assume that
1432 * conflicts are adjacent.
1433 *
1434 * We ignore defaulted arguments in deciding what is a match.
1435 */
1436 FuncCandidateList prevResult;
1439 {
1440 /* ndargs must be 0 if !any_special */
1446 else
1448 }
1449 else
1450 {
1454 prevResult;
1456 {
1462 }
1463 }
1466 {
1467 /*
1468 * We have a match with a previous result. Decide which one
1469 * to keep, or mark it ambiguous if we can't decide. The
1470 * logic here is preference > 0 means prefer the old result,
1471 * preference < 0 means prefer the new, preference = 0 means
1472 * ambiguous.
1473 */
1477 {
1478 /*
1479 * Prefer the one that's earlier in the search path.
1480 */
1482 }
1484 {
1485 /*
1486 * With variadic functions we could have, for example,
1487 * both foo(numeric) and foo(variadic numeric[]) in the
1488 * same namespace; if so we prefer the non-variadic match
1489 * on efficiency grounds.
1490 */
1492 }
1494 {
1496 }
1497 else
1498 {
1499 /*----------
1500 * We can't decide. This can happen with, for example,
1501 * both foo(numeric, variadic numeric[]) and
1502 * foo(variadic numeric[]) in the same namespace, or
1503 * both foo(int) and foo (int, int default something)
1504 * in the same namespace, or both foo(a int, b text)
1505 * and foo(b text, a int) in the same namespace.
1506 *----------
1507 */
1509 }
1512 {
1513 /* keep previous result */
1516 }
1518 {
1519 /* remove previous result from the list */
1522 else
1523 {
1524 FuncCandidateList prevPrevResult;
1527 prevPrevResult;
1529 {
1531 {
1534 }
1535 }
1537 }
1539 /* fall through to add newResult to list */
1540 }
1541 else
1542 {
1543 /* mark old result as ambiguous, discard new */
1547 }
1548 }
1549 }
1551 /*
1552 * Okay to add it to result list
1553 */
1556 }
1561 }
1563 /*
1564 * MatchNamedCall
1565 * Given a pg_proc heap tuple and a call's list of argument names,
1566 * check whether the function could match the call.
1567 *
1568 * The call could match if all supplied argument names are accepted by
1569 * the function, in positions after the last positional argument, and there
1570 * are defaults for all unsupplied arguments.
1571 *
1572 * If include_out_arguments is true, we are treating OUT arguments as
1573 * included in the argument list. pronargs is the number of arguments
1574 * we're considering (the length of either proargtypes or proallargtypes).
1575 *
1576 * The number of positional arguments is nargs - list_length(argnames).
1577 * Note caller has already done basic checks on argument count.
1578 *
1579 * On match, return true and fill *argnumbers with a palloc'd array showing
1580 * the mapping from call argument positions to actual function argument
1581 * numbers. Defaulted arguments are included in this map, at positions
1582 * after the last supplied argument.
1583 */
1584 static bool
1588 {
1605 /* Ignore this function if its proargnames is null */
1611 /* OK, let's extract the argument names and types */
1618 /* initialize state for matching */
1622 /* there are numposargs positional args before the named args */
1624 {
1627 }
1629 /* now examine the named args */
1631 {
1639 {
1640 /* consider only input params, except with include_out_arguments */
1642 p_argmodes &&
1648 {
1649 /* fail if argname matches a positional argument */
1656 }
1657 /* increase pp only for considered parameters */
1658 pp++;
1659 }
1660 /* if name isn't in proargnames, fail */
1663 ap++;
1664 }
1668 /* Check for default arguments */
1670 {
1674 {
1677 /* fail if arg not given and no default available */
1681 }
1682 }
1687 }
1689 /*
1690 * FunctionIsVisible
1691 * Determine whether a function (identified by OID) is visible in the
1692 * current search path. Visible means "would be found by searching
1693 * for the unqualified function name with exact argument matches".
1694 */
1695 bool
1697 {
1699 }
1701 /*
1702 * FunctionIsVisibleExt
1703 * As above, but if the function isn't found and is_missing is not NULL,
1704 * then set *is_missing = true and return false instead of throwing
1705 * an error. (Caller must initialize *is_missing = false.)
1706 */
1707 static bool
1709 {
1710 HeapTuple proctup;
1711 Form_pg_proc procform;
1712 Oid pronamespace;
1717 {
1719 {
1722 }
1724 }
1729 /*
1730 * Quick check: if it ain't in the path at all, it ain't visible. Items in
1731 * the system namespace are surely in the path and so we needn't even do
1732 * list_member_oid() for them.
1733 */
1738 else
1739 {
1740 /*
1741 * If it is in the path, it might still not be visible; it could be
1742 * hidden by another proc of the same name and arguments earlier in
1743 * the path. So we must do a slow check to see if this is the same
1744 * proc that would be found by FuncnameGetCandidates.
1745 */
1748 FuncCandidateList clist;
1756 {
1759 {
1760 /* Found the expected entry; is it the right proc? */
1763 }
1764 }
1765 }
1770 }
1773 /*
1774 * OpernameGetOprid
1775 * Given a possibly-qualified operator name and exact input datatypes,
1776 * look up the operator. Returns InvalidOid if not found.
1777 *
1778 * Pass oprleft = InvalidOid for a prefix op.
1779 *
1780 * If the operator name is not schema-qualified, it is sought in the current
1781 * namespace search path. If the name is schema-qualified and the given
1782 * schema does not exist, InvalidOid is returned.
1783 */
1784 Oid
1786 {
1792 /* deconstruct the name list */
1796 {
1797 /* search only in exact schema given */
1798 Oid namespaceId;
1802 {
1803 HeapTuple opertup;
1811 {
1817 }
1818 }
1821 }
1823 /* Search syscache by name and argument types */
1830 {
1831 /* no hope, fall out early */
1834 }
1836 /*
1837 * We have to find the list member that is first in the search path, if
1838 * there's more than one. This doubly-nested loop looks ugly, but in
1839 * practice there should usually be few catlist members.
1840 */
1844 {
1852 {
1857 {
1862 }
1863 }
1864 }
1868 }
1870 /*
1871 * OpernameGetCandidates
1872 * Given a possibly-qualified operator name and operator kind,
1873 * retrieve a list of the possible matches.
1874 *
1875 * If oprkind is '\0', we return all operators matching the given name,
1876 * regardless of arguments.
1877 *
1878 * We search a single namespace if the operator name is qualified, else
1879 * all namespaces in the search path. The return list will never contain
1880 * multiple entries with identical argument lists --- in the multiple-
1881 * namespace case, we arrange for entries in earlier namespaces to mask
1882 * identical entries in later namespaces.
1883 *
1884 * The returned items always have two args[] entries --- the first will be
1885 * InvalidOid for a prefix oprkind. nargs is always 2, too.
1886 */
1887 FuncCandidateList
1889 {
1895 Oid namespaceId;
1899 /* deconstruct the name list */
1903 {
1904 /* use exact schema given */
1908 }
1909 else
1910 {
1911 /* flag to indicate we need namespace search */
1914 }
1916 /* Search syscache by name only */
1919 /*
1920 * In typical scenarios, most if not all of the operators found by the
1921 * catcache search will end up getting returned; and there can be quite a
1922 * few, for common operator names such as '=' or '+'. To reduce the time
1923 * spent in palloc, we allocate the result space as an array large enough
1924 * to hold all the operators. The original coding of this routine did a
1925 * separate palloc for each operator, but profiling revealed that the
1926 * pallocs used an unreasonably large fraction of parsing time.
1927 */
1928 #define SPACE_PER_OP MAXALIGN(offsetof(struct _FuncCandidateList, args) + \
1929 2 * sizeof(Oid))
1935 {
1939 FuncCandidateList newResult;
1941 /* Ignore operators of wrong kind, if specific kind requested */
1946 {
1947 /* Consider only opers in specified namespace */
1950 /* No need to check args, they must all be different */
1951 }
1952 else
1953 {
1954 /*
1955 * Consider only opers that are in the search path and are not in
1956 * the temp namespace.
1957 */
1961 {
1965 pathpos++;
1966 }
1970 /*
1971 * Okay, it's in the search path, but does it have the same
1972 * arguments as something we already accepted? If so, keep only
1973 * the one that appears earlier in the search path.
1974 *
1975 * If we have an ordered list from SearchSysCacheList (the normal
1976 * case), then any conflicting oper must immediately adjoin this
1977 * one in the list, so we only need to look at the newest result
1978 * item. If we have an unordered list, we have to scan the whole
1979 * result list.
1980 */
1982 {
1983 FuncCandidateList prevResult;
1986 {
1990 else
1992 }
1993 else
1994 {
1996 prevResult;
1998 {
2002 }
2003 }
2005 {
2006 /* We have a match with a previous result */
2010 /* replace previous result */
2014 }
2015 }
2016 }
2018 /*
2019 * Okay to add it to result list
2020 */
2035 }
2040 }
2042 /*
2043 * OperatorIsVisible
2044 * Determine whether an operator (identified by OID) is visible in the
2045 * current search path. Visible means "would be found by searching
2046 * for the unqualified operator name with exact argument matches".
2047 */
2048 bool
2050 {
2052 }
2054 /*
2055 * OperatorIsVisibleExt
2056 * As above, but if the operator isn't found and is_missing is not NULL,
2057 * then set *is_missing = true and return false instead of throwing
2058 * an error. (Caller must initialize *is_missing = false.)
2059 */
2060 static bool
2062 {
2063 HeapTuple oprtup;
2064 Form_pg_operator oprform;
2065 Oid oprnamespace;
2070 {
2072 {
2075 }
2077 }
2082 /*
2083 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2084 * the system namespace are surely in the path and so we needn't even do
2085 * list_member_oid() for them.
2086 */
2091 else
2092 {
2093 /*
2094 * If it is in the path, it might still not be visible; it could be
2095 * hidden by another operator of the same name and arguments earlier
2096 * in the path. So we must do a slow check to see if this is the same
2097 * operator that would be found by OpernameGetOprid.
2098 */
2104 }
2109 }
2112 /*
2113 * OpclassnameGetOpcid
2114 * Try to resolve an unqualified index opclass name.
2115 * Returns OID if opclass found in search path, else InvalidOid.
2116 *
2117 * This is essentially the same as TypenameGetTypid, but we have to have
2118 * an extra argument for the index AM OID.
2119 */
2120 Oid
2122 {
2123 Oid opcid;
2129 {
2141 }
2143 /* Not found in path */
2145 }
2147 /*
2148 * OpclassIsVisible
2149 * Determine whether an opclass (identified by OID) is visible in the
2150 * current search path. Visible means "would be found by searching
2151 * for the unqualified opclass name".
2152 */
2153 bool
2155 {
2157 }
2159 /*
2160 * OpclassIsVisibleExt
2161 * As above, but if the opclass isn't found and is_missing is not NULL,
2162 * then set *is_missing = true and return false instead of throwing
2163 * an error. (Caller must initialize *is_missing = false.)
2164 */
2165 static bool
2167 {
2168 HeapTuple opctup;
2169 Form_pg_opclass opcform;
2170 Oid opcnamespace;
2175 {
2177 {
2180 }
2182 }
2187 /*
2188 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2189 * the system namespace are surely in the path and so we needn't even do
2190 * list_member_oid() for them.
2191 */
2196 else
2197 {
2198 /*
2199 * If it is in the path, it might still not be visible; it could be
2200 * hidden by another opclass of the same name earlier in the path. So
2201 * we must do a slow check to see if this opclass would be found by
2202 * OpclassnameGetOpcid.
2203 */
2207 }
2212 }
2214 /*
2215 * OpfamilynameGetOpfid
2216 * Try to resolve an unqualified index opfamily name.
2217 * Returns OID if opfamily found in search path, else InvalidOid.
2218 *
2219 * This is essentially the same as TypenameGetTypid, but we have to have
2220 * an extra argument for the index AM OID.
2221 */
2222 Oid
2224 {
2225 Oid opfid;
2231 {
2243 }
2245 /* Not found in path */
2247 }
2249 /*
2250 * OpfamilyIsVisible
2251 * Determine whether an opfamily (identified by OID) is visible in the
2252 * current search path. Visible means "would be found by searching
2253 * for the unqualified opfamily name".
2254 */
2255 bool
2257 {
2259 }
2261 /*
2262 * OpfamilyIsVisibleExt
2263 * As above, but if the opfamily isn't found and is_missing is not NULL,
2264 * then set *is_missing = true and return false instead of throwing
2265 * an error. (Caller must initialize *is_missing = false.)
2266 */
2267 static bool
2269 {
2270 HeapTuple opftup;
2271 Form_pg_opfamily opfform;
2272 Oid opfnamespace;
2277 {
2279 {
2282 }
2284 }
2289 /*
2290 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2291 * the system namespace are surely in the path and so we needn't even do
2292 * list_member_oid() for them.
2293 */
2298 else
2299 {
2300 /*
2301 * If it is in the path, it might still not be visible; it could be
2302 * hidden by another opfamily of the same name earlier in the path. So
2303 * we must do a slow check to see if this opfamily would be found by
2304 * OpfamilynameGetOpfid.
2305 */
2309 }
2314 }
2316 /*
2317 * lookup_collation
2318 * If there's a collation of the given name/namespace, and it works
2319 * with the given encoding, return its OID. Else return InvalidOid.
2320 */
2321 static Oid
2323 {
2324 Oid collid;
2325 HeapTuple colltup;
2326 Form_pg_collation collform;
2328 /* Check for encoding-specific entry (exact match) */
2336 /*
2337 * Check for any-encoding entry. This takes a bit more work: while libc
2338 * collations with collencoding = -1 do work with all encodings, ICU
2339 * collations only work with certain encodings, so we have to check that
2340 * aspect before deciding it's a match.
2341 */
2350 {
2353 else
2355 }
2356 else
2357 {
2359 }
2362 }
2364 /*
2365 * CollationGetCollid
2366 * Try to resolve an unqualified collation name.
2367 * Returns OID if collation found in search path, else InvalidOid.
2368 *
2369 * Note that this will only find collations that work with the current
2370 * database's encoding.
2371 */
2372 Oid
2374 {
2381 {
2383 Oid collid;
2391 }
2393 /* Not found in path */
2395 }
2397 /*
2398 * CollationIsVisible
2399 * Determine whether a collation (identified by OID) is visible in the
2400 * current search path. Visible means "would be found by searching
2401 * for the unqualified collation name".
2402 *
2403 * Note that only collations that work with the current database's encoding
2404 * will be considered visible.
2405 */
2406 bool
2408 {
2410 }
2412 /*
2413 * CollationIsVisibleExt
2414 * As above, but if the collation isn't found and is_missing is not NULL,
2415 * then set *is_missing = true and return false instead of throwing
2416 * an error. (Caller must initialize *is_missing = false.)
2417 */
2418 static bool
2420 {
2421 HeapTuple colltup;
2422 Form_pg_collation collform;
2423 Oid collnamespace;
2428 {
2430 {
2433 }
2435 }
2440 /*
2441 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2442 * the system namespace are surely in the path and so we needn't even do
2443 * list_member_oid() for them.
2444 */
2449 else
2450 {
2451 /*
2452 * If it is in the path, it might still not be visible; it could be
2453 * hidden by another collation of the same name earlier in the path,
2454 * or it might not work with the current DB encoding. So we must do a
2455 * slow check to see if this collation would be found by
2456 * CollationGetCollid.
2457 */
2461 }
2466 }
2469 /*
2470 * ConversionGetConid
2471 * Try to resolve an unqualified conversion name.
2472 * Returns OID if conversion found in search path, else InvalidOid.
2473 *
2474 * This is essentially the same as RelnameGetRelid.
2475 */
2476 Oid
2478 {
2479 Oid conid;
2485 {
2496 }
2498 /* Not found in path */
2500 }
2502 /*
2503 * ConversionIsVisible
2504 * Determine whether a conversion (identified by OID) is visible in the
2505 * current search path. Visible means "would be found by searching
2506 * for the unqualified conversion name".
2507 */
2508 bool
2510 {
2512 }
2514 /*
2515 * ConversionIsVisibleExt
2516 * As above, but if the conversion isn't found and is_missing is not NULL,
2517 * then set *is_missing = true and return false instead of throwing
2518 * an error. (Caller must initialize *is_missing = false.)
2519 */
2520 static bool
2522 {
2523 HeapTuple contup;
2524 Form_pg_conversion conform;
2525 Oid connamespace;
2530 {
2532 {
2535 }
2537 }
2542 /*
2543 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2544 * the system namespace are surely in the path and so we needn't even do
2545 * list_member_oid() for them.
2546 */
2551 else
2552 {
2553 /*
2554 * If it is in the path, it might still not be visible; it could be
2555 * hidden by another conversion of the same name earlier in the path.
2556 * So we must do a slow check to see if this conversion would be found
2557 * by ConversionGetConid.
2558 */
2562 }
2567 }
2569 /*
2570 * get_statistics_object_oid - find a statistics object by possibly qualified name
2571 *
2572 * If not found, returns InvalidOid if missing_ok, else throws error
2573 */
2574 Oid
2576 {
2579 Oid namespaceId;
2583 /* deconstruct the name list */
2587 {
2588 /* use exact schema given */
2592 else
2596 }
2597 else
2598 {
2599 /* search for it in search path */
2603 {
2613 }
2614 }
2623 }
2625 /*
2626 * StatisticsObjIsVisible
2627 * Determine whether a statistics object (identified by OID) is visible in
2628 * the current search path. Visible means "would be found by searching
2629 * for the unqualified statistics object name".
2630 */
2631 bool
2633 {
2635 }
2637 /*
2638 * StatisticsObjIsVisibleExt
2639 * As above, but if the statistics object isn't found and is_missing is
2640 * not NULL, then set *is_missing = true and return false instead of
2641 * throwing an error. (Caller must initialize *is_missing = false.)
2642 */
2643 static bool
2645 {
2646 HeapTuple stxtup;
2647 Form_pg_statistic_ext stxform;
2648 Oid stxnamespace;
2653 {
2655 {
2658 }
2660 }
2665 /*
2666 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2667 * the system namespace are surely in the path and so we needn't even do
2668 * list_member_oid() for them.
2669 */
2674 else
2675 {
2676 /*
2677 * If it is in the path, it might still not be visible; it could be
2678 * hidden by another statistics object of the same name earlier in the
2679 * path. So we must do a slow check for conflicting objects.
2680 */
2686 {
2690 {
2691 /* Found it first in path */
2694 }
2698 {
2699 /* Found something else first in path */
2701 }
2702 }
2703 }
2708 }
2710 /*
2711 * get_ts_parser_oid - find a TS parser by possibly qualified name
2712 *
2713 * If not found, returns InvalidOid if missing_ok, else throws error
2714 */
2715 Oid
2717 {
2720 Oid namespaceId;
2724 /* deconstruct the name list */
2728 {
2729 /* use exact schema given */
2733 else
2737 }
2738 else
2739 {
2740 /* search for it in search path */
2744 {
2755 }
2756 }
2765 }
2767 /*
2768 * TSParserIsVisible
2769 * Determine whether a parser (identified by OID) is visible in the
2770 * current search path. Visible means "would be found by searching
2771 * for the unqualified parser name".
2772 */
2773 bool
2775 {
2777 }
2779 /*
2780 * TSParserIsVisibleExt
2781 * As above, but if the parser isn't found and is_missing is not NULL,
2782 * then set *is_missing = true and return false instead of throwing
2783 * an error. (Caller must initialize *is_missing = false.)
2784 */
2785 static bool
2787 {
2788 HeapTuple tup;
2789 Form_pg_ts_parser form;
2795 {
2797 {
2800 }
2802 }
2807 /*
2808 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2809 * the system namespace are surely in the path and so we needn't even do
2810 * list_member_oid() for them.
2811 */
2816 else
2817 {
2818 /*
2819 * If it is in the path, it might still not be visible; it could be
2820 * hidden by another parser of the same name earlier in the path. So
2821 * we must do a slow check for conflicting parsers.
2822 */
2828 {
2835 {
2836 /* Found it first in path */
2839 }
2843 {
2844 /* Found something else first in path */
2846 }
2847 }
2848 }
2853 }
2855 /*
2856 * get_ts_dict_oid - find a TS dictionary by possibly qualified name
2857 *
2858 * If not found, returns InvalidOid if missing_ok, else throws error
2859 */
2860 Oid
2862 {
2865 Oid namespaceId;
2869 /* deconstruct the name list */
2873 {
2874 /* use exact schema given */
2878 else
2882 }
2883 else
2884 {
2885 /* search for it in search path */
2889 {
2900 }
2901 }
2910 }
2912 /*
2913 * TSDictionaryIsVisible
2914 * Determine whether a dictionary (identified by OID) is visible in the
2915 * current search path. Visible means "would be found by searching
2916 * for the unqualified dictionary name".
2917 */
2918 bool
2920 {
2922 }
2924 /*
2925 * TSDictionaryIsVisibleExt
2926 * As above, but if the dictionary isn't found and is_missing is not NULL,
2927 * then set *is_missing = true and return false instead of throwing
2928 * an error. (Caller must initialize *is_missing = false.)
2929 */
2930 static bool
2932 {
2933 HeapTuple tup;
2934 Form_pg_ts_dict form;
2940 {
2942 {
2945 }
2947 dictId);
2948 }
2953 /*
2954 * Quick check: if it ain't in the path at all, it ain't visible. Items in
2955 * the system namespace are surely in the path and so we needn't even do
2956 * list_member_oid() for them.
2957 */
2962 else
2963 {
2964 /*
2965 * If it is in the path, it might still not be visible; it could be
2966 * hidden by another dictionary of the same name earlier in the path.
2967 * So we must do a slow check for conflicting dictionaries.
2968 */
2974 {
2981 {
2982 /* Found it first in path */
2985 }
2989 {
2990 /* Found something else first in path */
2992 }
2993 }
2994 }
2999 }
3001 /*
3002 * get_ts_template_oid - find a TS template by possibly qualified name
3003 *
3004 * If not found, returns InvalidOid if missing_ok, else throws error
3005 */
3006 Oid
3008 {
3011 Oid namespaceId;
3015 /* deconstruct the name list */
3019 {
3020 /* use exact schema given */
3024 else
3028 }
3029 else
3030 {
3031 /* search for it in search path */
3035 {
3046 }
3047 }
3056 }
3058 /*
3059 * TSTemplateIsVisible
3060 * Determine whether a template (identified by OID) is visible in the
3061 * current search path. Visible means "would be found by searching
3062 * for the unqualified template name".
3063 */
3064 bool
3066 {
3068 }
3070 /*
3071 * TSTemplateIsVisibleExt
3072 * As above, but if the template isn't found and is_missing is not NULL,
3073 * then set *is_missing = true and return false instead of throwing
3074 * an error. (Caller must initialize *is_missing = false.)
3075 */
3076 static bool
3078 {
3079 HeapTuple tup;
3080 Form_pg_ts_template form;
3086 {
3088 {
3091 }
3093 }
3098 /*
3099 * Quick check: if it ain't in the path at all, it ain't visible. Items in
3100 * the system namespace are surely in the path and so we needn't even do
3101 * list_member_oid() for them.
3102 */
3107 else
3108 {
3109 /*
3110 * If it is in the path, it might still not be visible; it could be
3111 * hidden by another template of the same name earlier in the path. So
3112 * we must do a slow check for conflicting templates.
3113 */
3119 {
3126 {
3127 /* Found it first in path */
3130 }
3134 {
3135 /* Found something else first in path */
3137 }
3138 }
3139 }
3144 }
3146 /*
3147 * get_ts_config_oid - find a TS config by possibly qualified name
3148 *
3149 * If not found, returns InvalidOid if missing_ok, else throws error
3150 */
3151 Oid
3153 {
3156 Oid namespaceId;
3160 /* deconstruct the name list */
3164 {
3165 /* use exact schema given */
3169 else
3173 }
3174 else
3175 {
3176 /* search for it in search path */
3180 {
3191 }
3192 }
3201 }
3203 /*
3204 * TSConfigIsVisible
3205 * Determine whether a text search configuration (identified by OID)
3206 * is visible in the current search path. Visible means "would be found
3207 * by searching for the unqualified text search configuration name".
3208 */
3209 bool
3211 {
3213 }
3215 /*
3216 * TSConfigIsVisibleExt
3217 * As above, but if the configuration isn't found and is_missing is not
3218 * NULL, then set *is_missing = true and return false instead of throwing
3219 * an error. (Caller must initialize *is_missing = false.)
3220 */
3221 static bool
3223 {
3224 HeapTuple tup;
3225 Form_pg_ts_config form;
3231 {
3233 {
3236 }
3238 cfgid);
3239 }
3244 /*
3245 * Quick check: if it ain't in the path at all, it ain't visible. Items in
3246 * the system namespace are surely in the path and so we needn't even do
3247 * list_member_oid() for them.
3248 */
3253 else
3254 {
3255 /*
3256 * If it is in the path, it might still not be visible; it could be
3257 * hidden by another configuration of the same name earlier in the
3258 * path. So we must do a slow check for conflicting configurations.
3259 */
3265 {
3272 {
3273 /* Found it first in path */
3276 }
3280 {
3281 /* Found something else first in path */
3283 }
3284 }
3285 }
3290 }
3293 /*
3294 * DeconstructQualifiedName
3295 * Given a possibly-qualified name expressed as a list of String nodes,
3296 * extract the schema name and object name.
3297 *
3298 * *nspname_p is set to NULL if there is no explicit schema name.
3299 */
3300 void
3304 {
3310 {
3323 /*
3324 * We check the catalog name and then ignore it.
3325 */
3338 }
3342 }
3344 /*
3345 * LookupNamespaceNoError
3346 * Look up a schema name.
3347 *
3348 * Returns the namespace OID, or InvalidOid if not found.
3349 *
3350 * Note this does NOT perform any permissions check --- callers are
3351 * responsible for being sure that an appropriate check is made.
3352 * In the majority of cases LookupExplicitNamespace is preferable.
3353 */
3354 Oid
3356 {
3357 /* check for pg_temp alias */
3359 {
3361 {
3364 }
3366 /*
3367 * Since this is used only for looking up existing objects, there is
3368 * no point in trying to initialize the temp namespace here; and doing
3369 * so might create problems for some callers. Just report "not found".
3370 */
3372 }
3375 }
3377 /*
3378 * LookupExplicitNamespace
3379 * Process an explicitly-specified schema name: look up the schema
3380 * and verify we have USAGE (lookup) rights in it.
3381 *
3382 * Returns the namespace OID
3383 */
3384 Oid
3386 {
3387 Oid namespaceId;
3388 AclResult aclresult;
3390 /* check for pg_temp alias */
3392 {
3396 /*
3397 * Since this is used only for looking up existing objects, there is
3398 * no point in trying to initialize the temp namespace here; and doing
3399 * so might create problems for some callers --- just fall through.
3400 */
3401 }
3410 nspname);
3411 /* Schema search hook for this lookup */
3415 }
3417 /*
3418 * LookupCreationNamespace
3419 * Look up the schema and verify we have CREATE rights on it.
3420 *
3421 * This is just like LookupExplicitNamespace except for the different
3422 * permission check, and that we are willing to create pg_temp if needed.
3423 *
3424 * Note: calling this may result in a CommandCounterIncrement operation,
3425 * if we have to create or clean out the temp namespace.
3426 */
3427 Oid
3429 {
3430 Oid namespaceId;
3431 AclResult aclresult;
3433 /* check for pg_temp alias */
3435 {
3436 /* Initialize temp namespace */
3439 }
3446 nspname);
3449 }
3451 /*
3452 * Common checks on switching namespaces.
3453 *
3454 * We complain if either the old or new namespaces is a temporary schema
3455 * (or temporary toast schema), or if either the old or new namespaces is the
3456 * TOAST schema.
3457 */
3458 void
3460 {
3461 /* disallow renaming into or out of temp schemas */
3467 /* same for TOAST schema */
3472 }
3474 /*
3475 * QualifiedNameGetCreationNamespace
3476 * Given a possibly-qualified name for an object (in List-of-Strings
3477 * format), determine what namespace the object should be created in.
3478 * Also extract and return the object name (last component of list).
3479 *
3480 * Note: this does not apply any permissions check. Callers must check
3481 * for CREATE rights on the selected namespace when appropriate.
3482 *
3483 * Note: calling this may result in a CommandCounterIncrement operation,
3484 * if we have to create or clean out the temp namespace.
3485 */
3486 Oid
3488 {
3490 Oid namespaceId;
3492 /* deconstruct the name list */
3496 {
3497 /* check for pg_temp alias */
3499 {
3500 /* Initialize temp namespace */
3503 }
3504 /* use exact schema given */
3506 /* we do not check for USAGE rights here! */
3507 }
3508 else
3509 {
3510 /* use the default creation namespace */
3513 {
3514 /* Need to initialize temp namespace */
3517 }
3523 }
3526 }
3528 /*
3529 * get_namespace_oid - given a namespace name, look up the OID
3530 *
3531 * If missing_ok is false, throw an error if namespace name not found. If
3532 * true, just return InvalidOid.
3533 */
3534 Oid
3536 {
3537 Oid oid;
3547 }
3549 /*
3550 * makeRangeVarFromNameList
3551 * Utility routine to convert a qualified-name list into RangeVar form.
3552 */
3553 RangeVar *
3555 {
3559 {
3578 }
3581 }
3583 /*
3584 * NameListToString
3585 * Utility routine to convert a qualified-name list into a string.
3586 *
3587 * This is used primarily to form error messages, and so we do not quote
3588 * the list elements, for the sake of legibility.
3589 *
3590 * In most scenarios the list elements should always be String values,
3591 * but we also allow A_Star for the convenience of ColumnRef processing.
3592 */
3595 {
3596 StringInfoData string;
3602 {
3612 else
3615 }
3618 }
3620 /*
3621 * NameListToQuotedString
3622 * Utility routine to convert a qualified-name list into a string.
3623 *
3624 * Same as above except that names will be double-quoted where necessary,
3625 * so the string could be re-parsed (eg, by textToQualifiedNameList).
3626 */
3629 {
3630 StringInfoData string;
3636 {
3640 }
3643 }
3645 /*
3646 * isTempNamespace - is the given namespace my temporary-table namespace?
3647 */
3648 bool
3650 {
3654 }
3656 /*
3657 * isTempToastNamespace - is the given namespace my temporary-toast-table
3658 * namespace?
3659 */
3660 bool
3662 {
3666 }
3668 /*
3669 * isTempOrTempToastNamespace - is the given namespace my temporary-table
3670 * namespace or my temporary-toast-table namespace?
3671 */
3672 bool
3674 {
3679 }
3681 /*
3682 * isAnyTempNamespace - is the given namespace a temporary-table namespace
3683 * (either my own, or another backend's)? Temporary-toast-table namespaces
3684 * are included, too.
3685 */
3686 bool
3688 {
3692 /* True if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */
3700 }
3702 /*
3703 * isOtherTempNamespace - is the given namespace some other backend's
3704 * temporary-table namespace (including temporary-toast-table namespaces)?
3705 *
3706 * Note: for most purposes in the C code, this function is obsolete. Use
3707 * RELATION_IS_OTHER_TEMP() instead to detect non-local temp relations.
3708 */
3709 bool
3711 {
3712 /* If it's my own temp namespace, say "false" */
3715 /* Else, if it's any temp namespace, say "true" */
3717 }
3719 /*
3720 * checkTempNamespaceStatus - is the given namespace owned and actively used
3721 * by a backend?
3722 *
3723 * Note: this can be used while scanning relations in pg_class to detect
3724 * orphaned temporary tables or namespaces with a backend connected to a
3725 * given database. The result may be out of date quickly, so the caller
3726 * must be careful how to handle this information.
3727 */
3728 TempNamespaceStatus
3730 {
3732 ProcNumber procNumber;
3738 /* No such namespace, or its name shows it's not temp? */
3742 /* Is the backend alive? */
3747 /* Is the backend connected to the same database we are looking at? */
3751 /* Does the backend own the temporary namespace? */
3755 /* Yup, so namespace is busy */
3757 }
3759 /*
3760 * GetTempNamespaceProcNumber - if the given namespace is a temporary-table
3761 * namespace (either my own, or another backend's), return the proc number
3762 * that owns it. Temporary-toast-table namespaces are included, too.
3763 * If it isn't a temp namespace, return INVALID_PROC_NUMBER.
3764 */
3765 ProcNumber
3767 {
3771 /* See if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */
3779 else
3783 }
3785 /*
3786 * GetTempToastNamespace - get the OID of my temporary-toast-table namespace,
3787 * which must already be assigned. (This is only used when creating a toast
3788 * table for a temp table, so we must have already done InitTempTableNamespace)
3789 */
3790 Oid
3792 {
3795 }
3798 /*
3799 * GetTempNamespaceState - fetch status of session's temporary namespace
3800 *
3801 * This is used for conveying state to a parallel worker, and is not meant
3802 * for general-purpose access.
3803 */
3804 void
3806 {
3807 /* Return namespace OIDs, or 0 if session has not created temp namespace */
3810 }
3812 /*
3813 * SetTempNamespaceState - set status of session's temporary namespace
3814 *
3815 * This is used for conveying state to a parallel worker, and is not meant for
3816 * general-purpose access. By transferring these namespace OIDs to workers,
3817 * we ensure they will have the same notion of the search path as their leader
3818 * does.
3819 */
3820 void
3822 {
3823 /* Worker should not have created its own namespaces ... */
3828 /* Assign same namespace OIDs that leader has */
3832 /*
3833 * It's fine to leave myTempNamespaceSubID == InvalidSubTransactionId.
3834 * Even if the namespace is new so far as the leader is concerned, it's
3835 * not new to the worker, and we certainly wouldn't want the worker trying
3836 * to destroy it.
3837 */
3841 }
3844 /*
3845 * GetSearchPathMatcher - fetch current search path definition.
3846 *
3847 * The result structure is allocated in the specified memory context
3848 * (which might or might not be equal to CurrentMemoryContext); but any
3849 * junk created by revalidation calculations will be in CurrentMemoryContext.
3850 */
3851 SearchPathMatcher *
3853 {
3856 MemoryContext oldcxt;
3865 {
3868 else
3869 {
3872 }
3874 }
3881 }
3883 /*
3884 * CopySearchPathMatcher - copy the specified SearchPathMatcher.
3885 *
3886 * The result structure is allocated in CurrentMemoryContext.
3887 */
3888 SearchPathMatcher *
3890 {
3900 }
3902 /*
3903 * SearchPathMatchesCurrentEnvironment - does path match current environment?
3904 *
3905 * This is tested over and over in some common code paths, and in the typical
3906 * scenario where the active search path seldom changes, it'll always succeed.
3907 * We make that case fast by keeping a generation counter that is advanced
3908 * whenever the active search path changes.
3909 */
3910 bool
3912 {
3918 /* Quick out if already known equal to active path. */
3922 /* We scan down the activeSearchPath to see if it matches the input. */
3925 /* If path->addTemp, first item should be my temp namespace. */
3927 {
3930 else
3932 }
3933 /* If path->addCatalog, next item should be pg_catalog. */
3935 {
3938 else
3940 }
3941 /* We should now be looking at the activeCreationNamespace. */
3944 /* The remainder of activeSearchPath should match path->schemas. */
3946 {
3949 else
3951 }
3955 /*
3956 * Update path->generation so that future tests will return quickly, so
3957 * long as the active search path doesn't change.
3958 */
3962 }
3964 /*
3965 * get_collation_oid - find a collation by possibly qualified name
3966 *
3967 * Note that this will only find collations that work with the current
3968 * database's encoding.
3969 */
3970 Oid
3972 {
3976 Oid namespaceId;
3977 Oid colloid;
3980 /* deconstruct the name list */
3984 {
3985 /* use exact schema given */
3993 }
3994 else
3995 {
3996 /* search for it in search path */
4000 {
4009 }
4010 }
4012 /* Not found in path */
4019 }
4021 /*
4022 * get_conversion_oid - find a conversion by possibly qualified name
4023 */
4024 Oid
4026 {
4029 Oid namespaceId;
4033 /* deconstruct the name list */
4037 {
4038 /* use exact schema given */
4042 else
4046 }
4047 else
4048 {
4049 /* search for it in search path */
4053 {
4064 }
4065 }
4067 /* Not found in path */
4074 }
4076 /*
4077 * FindDefaultConversionProc - find default encoding conversion proc
4078 */
4079 Oid
4081 {
4082 Oid proc;
4088 {
4097 }
4099 /* Not found in path */
4101 }
4103 /*
4104 * Look up namespace IDs and perform ACL checks. Return newly-allocated list.
4105 */
4109 {
4115 /* Need a modifiable copy */
4118 /* Parse string into list of identifiers */
4120 {
4121 /* syntax error in name list */
4122 /* this should not happen if GUC checked check_search_path */
4124 }
4126 /*
4127 * Convert the list of names to a list of OIDs. If any names are not
4128 * recognizable or we don't have read access, just leave them out of the
4129 * list. (We can't raise an error, since the search_path setting has
4130 * already been accepted.) Don't make duplicate entries, either.
4131 */
4135 {
4137 Oid namespaceId;
4140 {
4141 /* $user --- substitute namespace matching user name, if any */
4142 HeapTuple tuple;
4146 {
4156 }
4157 }
4159 {
4160 /* pg_temp --- substitute temp namespace, if any */
4163 else
4164 {
4165 /* If it ought to be the creation namespace, set flag */
4168 }
4169 }
4170 else
4171 {
4172 /* normal namespace reference */
4178 }
4179 }
4185 }
4187 /*
4188 * Remove duplicates, run namespace search hooks, and prepend
4189 * implicitly-searched namespaces. Return newly-allocated list.
4190 *
4191 * If an object_access_hook is present, this must always be recalculated. It
4192 * may seem that duplicate elimination is not dependent on the result of the
4193 * hook, but if a hook returns different results on different calls for the
4194 * same namespace ID, then it could affect the order in which that namespace
4195 * appears in the final list.
4196 */
4199 {
4204 {
4208 {
4211 }
4212 }
4214 /*
4215 * Remember the first member of the explicit list. (Note: this is
4216 * nominally wrong if temp_missing, but we need it anyway to distinguish
4217 * explicit from implicit mention of pg_catalog.)
4218 */
4221 else
4224 /*
4225 * Add any implicitly-searched namespaces to the list. Note these go on
4226 * the front, not the back; also notice that we do not check USAGE
4227 * permissions for these.
4228 */
4237 }
4239 /*
4240 * Retrieve search path information from the cache; or if not there, fill
4241 * it. The returned entry is valid only until the next call to this function.
4242 */
4245 {
4246 MemoryContext oldcxt;
4253 /*
4254 * An OOM may have resulted in a cache entry with missing 'oidlist' or
4255 * 'finalPath', so just compute whatever is missing.
4256 */
4259 {
4264 }
4266 /*
4267 * If a hook is set, we must recompute finalPath from the oidlist each
4268 * time, because the hook may affect the result. This is still much faster
4269 * than recomputing from the string (and doing catalog lookups and ACL
4270 * checks).
4271 */
4274 {
4283 /*
4284 * If an object_access_hook is set when finalPath is calculated, the
4285 * result may be affected by the hook. Force recomputation of
4286 * finalPath the next time this cache entry is used, even if the
4287 * object_access_hook is not set at that time.
4288 */
4290 }
4293 }
4295 /*
4296 * recomputeNamespacePath - recompute path derived variables if needed.
4297 */
4298 static void
4300 {
4305 /* Do nothing if path is already valid. */
4314 {
4316 }
4317 else
4318 {
4319 MemoryContext oldcxt;
4324 /* Must save OID list in permanent storage. */
4329 /* Now safe to assign to state variables. */
4334 }
4336 /* Mark the path valid. */
4340 /* And make it active. */
4345 /*
4346 * Bump the generation only if something actually changed. (Notice that
4347 * what we compared to was the old state of the base path variables.)
4348 */
4350 activePathGeneration++;
4351 }
4353 /*
4354 * AccessTempTableNamespace
4355 * Provide access to a temporary namespace, potentially creating it
4356 * if not present yet. This routine registers if the namespace gets
4357 * in use in this transaction. 'force' can be set to true to allow
4358 * the caller to enforce the creation of the temporary namespace for
4359 * use in this backend, which happens if its creation is pending.
4360 */
4361 static void
4363 {
4364 /*
4365 * Make note that this temporary namespace has been accessed in this
4366 * transaction.
4367 */
4370 /*
4371 * If the caller attempting to access a temporary schema expects the
4372 * creation of the namespace to be pending and should be enforced, then go
4373 * through the creation.
4374 */
4378 /*
4379 * The temporary tablespace does not exist yet and is wanted, so
4380 * initialize it.
4381 */
4383 }
4385 /*
4386 * InitTempTableNamespace
4387 * Initialize temp table namespace on first use in a particular backend
4388 */
4389 static void
4391 {
4393 Oid namespaceId;
4394 Oid toastspaceId;
4398 /*
4399 * First, do permission check to see if we are authorized to make temp
4400 * tables. We use a nonstandard error message here since "databasename:
4401 * permission denied" might be a tad cryptic.
4402 *
4403 * Note that ACL_CREATE_TEMP rights are rechecked in pg_namespace_aclmask;
4404 * that's necessary since current user ID could change during the session.
4405 * But there's no need to make the namespace in the first place until a
4406 * temp table creation request is made by someone with appropriate rights.
4407 */
4415 /*
4416 * Do not allow a Hot Standby session to make temp tables. Aside from
4417 * problems with modifying the system catalogs, there is a naming
4418 * conflict: pg_temp_N belongs to the session with proc number N on the
4419 * primary, not to a hot standby session with the same proc number. We
4420 * should not be able to get here anyway due to XactReadOnly checks, but
4421 * let's just make real sure. Note that this also backstops various
4422 * operations that allow XactReadOnly transactions to modify temp tables;
4423 * they'd need RecoveryInProgress checks if not for this.
4424 */
4430 /* Parallel workers can't create temporary tables, either. */
4440 {
4441 /*
4442 * First use of this temp namespace in this database; create it. The
4443 * temp namespaces are always owned by the superuser. We leave their
4444 * permissions at default --- i.e., no access except to superuser ---
4445 * to ensure that unprivileged users can't peek at other backends'
4446 * temp tables. This works because the places that access the temp
4447 * namespace for my own backend skip permissions checks on it.
4448 */
4451 /* Advance command counter to make namespace visible */
4453 }
4454 else
4455 {
4456 /*
4457 * If the namespace already exists, clean it out (in case the former
4458 * owner crashed without doing so).
4459 */
4461 }
4463 /*
4464 * If the corresponding toast-table namespace doesn't exist yet, create
4465 * it. (We assume there is no need to clean it out if it does exist, since
4466 * dropping a parent table should make its toast table go away.)
4467 */
4469 MyProcNumber);
4473 {
4476 /* Advance command counter to make namespace visible */
4478 }
4480 /*
4481 * Okay, we've prepared the temp namespace ... but it's not committed yet,
4482 * so all our work could be undone by transaction rollback. Set flag for
4483 * AtEOXact_Namespace to know what to do.
4484 */
4488 /*
4489 * Mark MyProc as owning this namespace which other processes can use to
4490 * decide if a temporary namespace is in use or not. We assume that
4491 * assignment of namespaceId is an atomic operation. Even if it is not,
4492 * the temporary relation which resulted in the creation of this temporary
4493 * namespace is still locked until the current transaction commits, and
4494 * its pg_namespace row is not visible yet. However it does not matter:
4495 * this flag makes the namespace as being in use, so no objects created on
4496 * it would be removed concurrently.
4497 */
4500 /* It should not be done already. */
4506 }
4508 /*
4509 * End-of-transaction cleanup for namespaces.
4510 */
4511 void
4513 {
4514 /*
4515 * If we abort the transaction in which a temp namespace was selected,
4516 * we'll have to do any creation or cleanout work over again. So, just
4517 * forget the namespace entirely until next time. On the other hand, if
4518 * we commit then register an exit callback to clean out the temp tables
4519 * at backend shutdown. (We only want to register the callback once per
4520 * session, so this is a good place to do it.)
4521 */
4523 {
4526 else
4527 {
4533 /*
4534 * Reset the temporary namespace flag in MyProc. We assume that
4535 * this operation is atomic.
4536 *
4537 * Because this transaction is aborting, the pg_namespace row is
4538 * not visible to anyone else anyway, but that doesn't matter:
4539 * it's not a problem if objects contained in this namespace are
4540 * removed concurrently.
4541 */
4543 }
4545 }
4547 }
4549 /*
4550 * AtEOSubXact_Namespace
4551 *
4552 * At subtransaction commit, propagate the temp-namespace-creation
4553 * flag to the parent subtransaction.
4554 *
4555 * At subtransaction abort, forget the flag if we set it up.
4556 */
4557 void
4559 SubTransactionId parentSubid)
4560 {
4563 {
4566 else
4567 {
4569 /* TEMP namespace creation failed, so reset state */
4575 /*
4576 * Reset the temporary namespace flag in MyProc. We assume that
4577 * this operation is atomic.
4578 *
4579 * Because this subtransaction is aborting, the pg_namespace row
4580 * is not visible to anyone else anyway, but that doesn't matter:
4581 * it's not a problem if objects contained in this namespace are
4582 * removed concurrently.
4583 */
4585 }
4586 }
4587 }
4589 /*
4590 * Remove all relations in the specified temp namespace.
4591 *
4592 * This is called at backend shutdown (if we made any temp relations).
4593 * It is also called when we begin using a pre-existing temp namespace,
4594 * in order to clean out any relations that might have been created by
4595 * a crashed backend.
4596 */
4597 static void
4599 {
4600 ObjectAddress object;
4602 /*
4603 * We want to get rid of everything in the target namespace, but not the
4604 * namespace itself (deleting it only to recreate it later would be a
4605 * waste of cycles). Hence, specify SKIP_ORIGINAL. It's also an INTERNAL
4606 * deletion, and we want to not drop any extensions that might happen to
4607 * own temp objects.
4608 */
4614 PERFORM_DELETION_INTERNAL |
4615 PERFORM_DELETION_QUIETLY |
4616 PERFORM_DELETION_SKIP_ORIGINAL |
4617 PERFORM_DELETION_SKIP_EXTENSIONS);
4618 }
4620 /*
4621 * Callback to remove temp relations at backend exit.
4622 */
4623 static void
4625 {
4627 {
4628 /* Need to ensure we have a usable transaction. */
4637 }
4638 }
4640 /*
4641 * Remove all temp tables from the temporary namespace.
4642 */
4643 void
4645 {
4648 }
4651 /*
4652 * Routines for handling the GUC variable 'search_path'.
4653 */
4655 /* check_hook: validate new search_path value */
4656 bool
4658 {
4665 /*
4666 * We used to try to check that the named schemas exist, but there are
4667 * many valid use-cases for having search_path settings that include
4668 * schemas that don't exist; and often, we are not inside a transaction
4669 * here and so can't consult the system catalogs anyway. So now, the only
4670 * requirement is syntactic validity of the identifier list.
4671 *
4672 * Checking only the syntactic validity also allows us to use the search
4673 * path cache (if available) to avoid calling SplitIdentifierString() on
4674 * the same string repeatedly.
4675 */
4677 {
4684 }
4686 /*
4687 * Ensure validity check succeeds before creating cache entry.
4688 */
4692 /* Parse string into list of identifiers */
4694 {
4695 /* syntax error in name list */
4700 }
4704 /* OK to create empty cache entry */
4709 }
4711 /* assign_hook: do extra actions as needed */
4712 void
4714 {
4715 /* don't access search_path during bootstrap */
4718 /*
4719 * We mark the path as needing recomputation, but don't do anything until
4720 * it's needed. This avoids trying to do database access during GUC
4721 * initialization, or outside a transaction.
4722 *
4723 * This does not invalidate the search path cache, so if this value had
4724 * been previously set and no syscache invalidations happened,
4725 * recomputation may not be necessary.
4726 */
4728 }
4730 /*
4731 * InitializeSearchPath: initialize module during InitPostgres.
4732 *
4733 * This is called after we are up enough to be able to do catalog lookups.
4734 */
4735 void
4737 {
4739 {
4740 /*
4741 * In bootstrap mode, the search path must be 'pg_catalog' so that
4742 * tables are created in the proper namespace; ignore the GUC setting.
4743 */
4744 MemoryContext oldcxt;
4757 }
4758 else
4759 {
4760 /*
4761 * In normal mode, arrange for a callback on any syscache invalidation
4762 * that will affect the search_path cache.
4763 */
4765 /* namespace name or ACLs may have changed */
4767 InvalidationCallback,
4770 /* role name may affect the meaning of "$user" */
4772 InvalidationCallback,
4775 /* role membership may affect ACLs */
4777 InvalidationCallback,
4780 /* database owner may affect ACLs */
4782 InvalidationCallback,
4785 /* Force search path to be recomputed on next use */
4788 }
4789 }
4791 /*
4792 * InvalidationCallback
4793 * Syscache inval callback function
4794 */
4795 static void
4797 {
4798 /*
4799 * Force search path to be recomputed on next use, also invalidating the
4800 * search path cache (because namespace names, ACLs, or role names may
4801 * have changed).
4802 */
4805 }
4807 /*
4808 * Fetch the active search path. The return value is a palloc'ed list
4809 * of OIDs; the caller is responsible for freeing this storage as
4810 * appropriate.
4811 *
4812 * The returned list includes the implicitly-prepended namespaces only if
4813 * includeImplicit is true.
4814 *
4815 * Note: calling this may result in a CommandCounterIncrement operation,
4816 * if we have to create or clean out the temp namespace.
4817 */
4818 List *
4820 {
4825 /*
4826 * If the temp namespace should be first, force it to exist. This is so
4827 * that callers can trust the result to reflect the actual default
4828 * creation namespace. It's a bit bogus to do this here, since
4829 * current_schema() is supposedly a stable function without side-effects,
4830 * but the alternatives seem worse.
4831 */
4833 {
4836 }
4840 {
4843 }
4846 }
4848 /*
4849 * Fetch the active search path into a caller-allocated array of OIDs.
4850 * Returns the number of path entries. (If this is more than sarray_len,
4851 * then the data didn't fit and is not all stored.)
4852 *
4853 * The returned list always includes the implicitly-prepended namespaces,
4854 * but never includes the temp namespace. (This is suitable for existing
4855 * users, which would want to ignore the temp namespace anyway.) This
4856 * definition allows us to not worry about initializing the temp namespace.
4857 */
4858 int
4860 {
4867 {
4875 count++;
4876 }
4879 }
4882 /*
4883 * Export the FooIsVisible functions as SQL-callable functions.
4884 *
4885 * Note: as of Postgres 8.4, these will silently return NULL if called on
4886 * a nonexistent object OID, rather than failing. This is to avoid race
4887 * condition errors when a query that's scanning a catalog using an MVCC
4888 * snapshot uses one of these functions. The underlying IsVisible functions
4889 * always use an up-to-date snapshot and so might see the object as already
4890 * gone when it's still visible to the transaction snapshot.
4891 */
4893 Datum
4895 {
4905 }
4907 Datum
4909 {
4919 }
4921 Datum
4923 {
4933 }
4935 Datum
4937 {
4947 }
4949 Datum
4951 {
4961 }
4963 Datum
4965 {
4975 }
4977 Datum
4979 {
4989 }
4991 Datum
4993 {
5003 }
5005 Datum
5007 {
5017 }
5019 Datum
5021 {
5031 }
5033 Datum
5035 {
5045 }
5047 Datum
5049 {
5059 }
5061 Datum
5063 {
5073 }
5075 Datum
5077 {
5079 }
5081 Datum
5083 {
5087 }