Branch data Line data Source code
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-2026, 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 : : */
20 : : #include "postgres.h"
21 : :
22 : : #include "access/htup_details.h"
23 : : #include "access/parallel.h"
24 : : #include "access/xact.h"
25 : : #include "access/xlog.h"
26 : : #include "catalog/dependency.h"
27 : : #include "catalog/namespace.h"
28 : : #include "catalog/objectaccess.h"
29 : : #include "catalog/pg_authid.h"
30 : : #include "catalog/pg_collation.h"
31 : : #include "catalog/pg_conversion.h"
32 : : #include "catalog/pg_database.h"
33 : : #include "catalog/pg_namespace.h"
34 : : #include "catalog/pg_opclass.h"
35 : : #include "catalog/pg_operator.h"
36 : : #include "catalog/pg_opfamily.h"
37 : : #include "catalog/pg_proc.h"
38 : : #include "catalog/pg_statistic_ext.h"
39 : : #include "catalog/pg_ts_config.h"
40 : : #include "catalog/pg_ts_dict.h"
41 : : #include "catalog/pg_ts_parser.h"
42 : : #include "catalog/pg_ts_template.h"
43 : : #include "catalog/pg_type.h"
44 : : #include "common/hashfn_unstable.h"
45 : : #include "funcapi.h"
46 : : #include "mb/pg_wchar.h"
47 : : #include "miscadmin.h"
48 : : #include "nodes/makefuncs.h"
49 : : #include "storage/ipc.h"
50 : : #include "storage/lmgr.h"
51 : : #include "storage/procarray.h"
52 : : #include "utils/acl.h"
53 : : #include "utils/builtins.h"
54 : : #include "utils/catcache.h"
55 : : #include "utils/guc_hooks.h"
56 : : #include "utils/inval.h"
57 : : #include "utils/lsyscache.h"
58 : : #include "utils/memutils.h"
59 : : #include "utils/snapmgr.h"
60 : : #include "utils/syscache.h"
61 : : #include "utils/varlena.h"
62 : :
63 : :
64 : : /*
65 : : * The namespace search path is a possibly-empty list of namespace OIDs.
66 : : * In addition to the explicit list, implicitly-searched namespaces
67 : : * may be included:
68 : : *
69 : : * 1. If a TEMP table namespace has been initialized in this session, it
70 : : * is implicitly searched first.
71 : : *
72 : : * 2. The system catalog namespace is always searched. If the system
73 : : * namespace is present in the explicit path then it will be searched in
74 : : * the specified order; otherwise it will be searched after TEMP tables and
75 : : * *before* the explicit list. (It might seem that the system namespace
76 : : * should be implicitly last, but this behavior appears to be required by
77 : : * SQL99. Also, this provides a way to search the system namespace first
78 : : * without thereby making it the default creation target namespace.)
79 : : *
80 : : * For security reasons, searches using the search path will ignore the temp
81 : : * namespace when searching for any object type other than relations and
82 : : * types. (We must allow types since temp tables have rowtypes.)
83 : : *
84 : : * The default creation target namespace is always the first element of the
85 : : * explicit list. If the explicit list is empty, there is no default target.
86 : : *
87 : : * The textual specification of search_path can include "$user" to refer to
88 : : * the namespace named the same as the current user, if any. (This is just
89 : : * ignored if there is no such namespace.) Also, it can include "pg_temp"
90 : : * to refer to the current backend's temp namespace. This is usually also
91 : : * ignorable if the temp namespace hasn't been set up, but there's a special
92 : : * case: if "pg_temp" appears first then it should be the default creation
93 : : * target. We kluge this case a little bit so that the temp namespace isn't
94 : : * set up until the first attempt to create something in it. (The reason for
95 : : * klugery is that we can't create the temp namespace outside a transaction,
96 : : * but initial GUC processing of search_path happens outside a transaction.)
97 : : * activeTempCreationPending is true if "pg_temp" appears first in the string
98 : : * but is not reflected in activeCreationNamespace because the namespace isn't
99 : : * set up yet.
100 : : *
101 : : * In bootstrap mode, the search path is set equal to "pg_catalog", so that
102 : : * the system namespace is the only one searched or inserted into.
103 : : * initdb is also careful to set search_path to "pg_catalog" for its
104 : : * post-bootstrap standalone backend runs. Otherwise the default search
105 : : * path is determined by GUC. The factory default path contains the PUBLIC
106 : : * namespace (if it exists), preceded by the user's personal namespace
107 : : * (if one exists).
108 : : *
109 : : * activeSearchPath is always the actually active path; it points to
110 : : * baseSearchPath which is the list derived from namespace_search_path.
111 : : *
112 : : * If baseSearchPathValid is false, then baseSearchPath (and other derived
113 : : * variables) need to be recomputed from namespace_search_path, or retrieved
114 : : * from the search path cache if there haven't been any syscache
115 : : * invalidations. We mark it invalid upon an assignment to
116 : : * namespace_search_path or receipt of a syscache invalidation event for
117 : : * pg_namespace or pg_authid. The recomputation is done during the next
118 : : * lookup attempt.
119 : : *
120 : : * Any namespaces mentioned in namespace_search_path that are not readable
121 : : * by the current user ID are simply left out of baseSearchPath; so
122 : : * we have to be willing to recompute the path when current userid changes.
123 : : * namespaceUser is the userid the path has been computed for.
124 : : *
125 : : * Note: all data pointed to by these List variables is in TopMemoryContext.
126 : : *
127 : : * activePathGeneration is incremented whenever the effective values of
128 : : * activeSearchPath/activeCreationNamespace/activeTempCreationPending change.
129 : : * This can be used to quickly detect whether any change has happened since
130 : : * a previous examination of the search path state.
131 : : */
132 : :
133 : : /* These variables define the actually active state: */
134 : :
135 : : static List *activeSearchPath = NIL;
136 : :
137 : : /* default place to create stuff; if InvalidOid, no default */
138 : : static Oid activeCreationNamespace = InvalidOid;
139 : :
140 : : /* if true, activeCreationNamespace is wrong, it should be temp namespace */
141 : : static bool activeTempCreationPending = false;
142 : :
143 : : /* current generation counter; make sure this is never zero */
144 : : static uint64 activePathGeneration = 1;
145 : :
146 : : /* These variables are the values last derived from namespace_search_path: */
147 : :
148 : : static List *baseSearchPath = NIL;
149 : :
150 : : static Oid baseCreationNamespace = InvalidOid;
151 : :
152 : : static bool baseTempCreationPending = false;
153 : :
154 : : static Oid namespaceUser = InvalidOid;
155 : :
156 : : /* The above four values are valid only if baseSearchPathValid */
157 : : static bool baseSearchPathValid = true;
158 : :
159 : : /*
160 : : * Storage for search path cache. Clear searchPathCacheValid as a simple
161 : : * way to invalidate *all* the cache entries, not just the active one.
162 : : */
163 : : static bool searchPathCacheValid = false;
164 : : static MemoryContext SearchPathCacheContext = NULL;
165 : :
166 : : typedef struct SearchPathCacheKey
167 : : {
168 : : const char *searchPath;
169 : : Oid roleid;
170 : : } SearchPathCacheKey;
171 : :
172 : : typedef struct SearchPathCacheEntry
173 : : {
174 : : SearchPathCacheKey key;
175 : : List *oidlist; /* namespace OIDs that pass ACL checks */
176 : : List *finalPath; /* cached final computed search path */
177 : : Oid firstNS; /* first explicitly-listed namespace */
178 : : bool temp_missing;
179 : : bool forceRecompute; /* force recompute of finalPath */
180 : :
181 : : /* needed for simplehash */
182 : : char status;
183 : : } SearchPathCacheEntry;
184 : :
185 : : /*
186 : : * myTempNamespace is InvalidOid until and unless a TEMP namespace is set up
187 : : * in a particular backend session (this happens when a CREATE TEMP TABLE
188 : : * command is first executed). Thereafter it's the OID of the temp namespace.
189 : : *
190 : : * myTempToastNamespace is the OID of the namespace for my temp tables' toast
191 : : * tables. It is set when myTempNamespace is, and is InvalidOid before that.
192 : : *
193 : : * myTempNamespaceSubID shows whether we've created the TEMP namespace in the
194 : : * current subtransaction. The flag propagates up the subtransaction tree,
195 : : * so the main transaction will correctly recognize the flag if all
196 : : * intermediate subtransactions commit. When it is InvalidSubTransactionId,
197 : : * we either haven't made the TEMP namespace yet, or have successfully
198 : : * committed its creation, depending on whether myTempNamespace is valid.
199 : : */
200 : : static Oid myTempNamespace = InvalidOid;
201 : :
202 : : static Oid myTempToastNamespace = InvalidOid;
203 : :
204 : : static SubTransactionId myTempNamespaceSubID = InvalidSubTransactionId;
205 : :
206 : : /*
207 : : * This is the user's textual search path specification --- it's the value
208 : : * of the GUC variable 'search_path'.
209 : : */
210 : : char *namespace_search_path = NULL;
211 : :
212 : :
213 : : /* Local functions */
214 : : static bool RelationIsVisibleExt(Oid relid, bool *is_missing);
215 : : static bool TypeIsVisibleExt(Oid typid, bool *is_missing);
216 : : static bool FunctionIsVisibleExt(Oid funcid, bool *is_missing);
217 : : static bool OperatorIsVisibleExt(Oid oprid, bool *is_missing);
218 : : static bool OpclassIsVisibleExt(Oid opcid, bool *is_missing);
219 : : static bool OpfamilyIsVisibleExt(Oid opfid, bool *is_missing);
220 : : static bool CollationIsVisibleExt(Oid collid, bool *is_missing);
221 : : static bool ConversionIsVisibleExt(Oid conid, bool *is_missing);
222 : : static bool StatisticsObjIsVisibleExt(Oid stxid, bool *is_missing);
223 : : static bool TSParserIsVisibleExt(Oid prsId, bool *is_missing);
224 : : static bool TSDictionaryIsVisibleExt(Oid dictId, bool *is_missing);
225 : : static bool TSTemplateIsVisibleExt(Oid tmplId, bool *is_missing);
226 : : static bool TSConfigIsVisibleExt(Oid cfgid, bool *is_missing);
227 : : static void recomputeNamespacePath(void);
228 : : static void AccessTempTableNamespace(bool force);
229 : : static void InitTempTableNamespace(void);
230 : : static void RemoveTempRelations(Oid tempNamespaceId);
231 : : static void RemoveTempRelationsCallback(int code, Datum arg);
232 : : static void InvalidationCallback(Datum arg, int cacheid, uint32 hashvalue);
233 : : static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
234 : : bool include_out_arguments, int pronargs,
235 : : int **argnumbers, int *fgc_flags);
236 : :
237 : : /*
238 : : * Recomputing the namespace path can be costly when done frequently, such as
239 : : * when a function has search_path set in proconfig. Add a search path cache
240 : : * that can be used by recomputeNamespacePath().
241 : : *
242 : : * The cache is also used to remember already-validated strings in
243 : : * check_search_path() to avoid the need to call SplitIdentifierString()
244 : : * repeatedly.
245 : : *
246 : : * The search path cache is based on a wrapper around a simplehash hash table
247 : : * (nsphash, defined below). The spcache wrapper deals with OOM while trying
248 : : * to initialize a key, optimizes repeated lookups of the same key, and also
249 : : * offers a more convenient API.
250 : : */
251 : :
252 : : static inline uint32
253 : 17947 : spcachekey_hash(SearchPathCacheKey key)
254 : : {
255 : 17947 : fasthash_state hs;
256 : 17947 : int sp_len;
257 : :
258 : 17947 : fasthash_init(&hs, 0);
259 : :
260 : 17947 : hs.accum = key.roleid;
261 : 17947 : fasthash_combine(&hs);
262 : :
263 : : /*
264 : : * Combine search path into the hash and save the length for tweaking the
265 : : * final mix.
266 : : */
267 : 17947 : sp_len = fasthash_accum_cstring(&hs, key.searchPath);
268 : :
269 : 35894 : return fasthash_final32(&hs, sp_len);
270 : 17947 : }
271 : :
272 : : static inline bool
273 : 7383 : spcachekey_equal(SearchPathCacheKey a, SearchPathCacheKey b)
274 : : {
275 [ + + ]: 14692 : return a.roleid == b.roleid &&
276 : 7309 : strcmp(a.searchPath, b.searchPath) == 0;
277 : : }
278 : :
279 : : #define SH_PREFIX nsphash
280 : : #define SH_ELEMENT_TYPE SearchPathCacheEntry
281 : : #define SH_KEY_TYPE SearchPathCacheKey
282 : : #define SH_KEY key
283 : : #define SH_HASH_KEY(tb, key) spcachekey_hash(key)
284 : : #define SH_EQUAL(tb, a, b) spcachekey_equal(a, b)
285 : : #define SH_SCOPE static inline
286 : : #define SH_DECLARE
287 : : #define SH_DEFINE
288 : : #include "lib/simplehash.h"
289 : :
290 : : /*
291 : : * We only expect a small number of unique search_path strings to be used. If
292 : : * this cache grows to an unreasonable size, reset it to avoid steady-state
293 : : * memory growth. Most likely, only a few of those entries will benefit from
294 : : * the cache, and the cache will be quickly repopulated with such entries.
295 : : */
296 : : #define SPCACHE_RESET_THRESHOLD 256
297 : :
298 : : static nsphash_hash *SearchPathCache = NULL;
299 : : static SearchPathCacheEntry *LastSearchPathCacheEntry = NULL;
300 : :
301 : : /*
302 : : * Create or reset search_path cache as necessary.
303 : : */
304 : : static void
305 : 21165 : spcache_init(void)
306 : : {
307 [ + + + + : 21165 : if (SearchPathCache && searchPathCacheValid &&
- + ]
308 : 17327 : SearchPathCache->members < SPCACHE_RESET_THRESHOLD)
309 : 17327 : return;
310 : :
311 : 3838 : searchPathCacheValid = false;
312 : 3838 : baseSearchPathValid = false;
313 : :
314 : : /*
315 : : * Make sure we don't leave dangling pointers if a failure happens during
316 : : * initialization.
317 : : */
318 : 3838 : SearchPathCache = NULL;
319 : 3838 : LastSearchPathCacheEntry = NULL;
320 : :
321 [ + + ]: 3838 : if (SearchPathCacheContext == NULL)
322 : : {
323 : : /* Make the context we'll keep search path cache hashtable in */
324 : 315 : SearchPathCacheContext = AllocSetContextCreate(TopMemoryContext,
325 : : "search_path processing cache",
326 : : ALLOCSET_DEFAULT_SIZES);
327 : 315 : }
328 : : else
329 : : {
330 : 3523 : MemoryContextReset(SearchPathCacheContext);
331 : : }
332 : :
333 : : /* arbitrary initial starting size of 16 elements */
334 : 3838 : SearchPathCache = nsphash_create(SearchPathCacheContext, 16, NULL);
335 : 3838 : searchPathCacheValid = true;
336 : 21165 : }
337 : :
338 : : /*
339 : : * Look up entry in search path cache without inserting. Returns NULL if not
340 : : * present.
341 : : */
342 : : static SearchPathCacheEntry *
343 : 13098 : spcache_lookup(const char *searchPath, Oid roleid)
344 : : {
345 [ + + ]: 13098 : if (LastSearchPathCacheEntry &&
346 [ + + + + ]: 12779 : LastSearchPathCacheEntry->key.roleid == roleid &&
347 : 12742 : strcmp(LastSearchPathCacheEntry->key.searchPath, searchPath) == 0)
348 : : {
349 : 8848 : return LastSearchPathCacheEntry;
350 : : }
351 : : else
352 : : {
353 : 4250 : SearchPathCacheEntry *entry;
354 : 12750 : SearchPathCacheKey cachekey = {
355 : 4250 : .searchPath = searchPath,
356 : 4250 : .roleid = roleid
357 : : };
358 : :
359 : 4250 : entry = nsphash_lookup(SearchPathCache, cachekey);
360 [ + + ]: 4250 : if (entry)
361 : 3221 : LastSearchPathCacheEntry = entry;
362 : 4250 : return entry;
363 : 4250 : }
364 : 13098 : }
365 : :
366 : : /*
367 : : * Look up or insert entry in search path cache.
368 : : *
369 : : * Initialize key safely, so that OOM does not leave an entry without a valid
370 : : * key. Caller must ensure that non-key contents are properly initialized.
371 : : */
372 : : static SearchPathCacheEntry *
373 : 9096 : spcache_insert(const char *searchPath, Oid roleid)
374 : : {
375 [ + + ]: 9096 : if (LastSearchPathCacheEntry &&
376 [ + + + + ]: 5258 : LastSearchPathCacheEntry->key.roleid == roleid &&
377 : 4695 : strcmp(LastSearchPathCacheEntry->key.searchPath, searchPath) == 0)
378 : : {
379 : 267 : return LastSearchPathCacheEntry;
380 : : }
381 : : else
382 : : {
383 : 8829 : SearchPathCacheEntry *entry;
384 : 26487 : SearchPathCacheKey cachekey = {
385 : 8829 : .searchPath = searchPath,
386 : 8829 : .roleid = roleid
387 : : };
388 : :
389 : : /*
390 : : * searchPath is not saved in SearchPathCacheContext. First perform a
391 : : * lookup, and copy searchPath only if we need to create a new entry.
392 : : */
393 : 8829 : entry = nsphash_lookup(SearchPathCache, cachekey);
394 : :
395 [ + + ]: 8829 : if (!entry)
396 : : {
397 : 4842 : bool found;
398 : :
399 : 4842 : cachekey.searchPath = MemoryContextStrdup(SearchPathCacheContext, searchPath);
400 : 4842 : entry = nsphash_insert(SearchPathCache, cachekey, &found);
401 [ + - ]: 4842 : Assert(!found);
402 : :
403 : 4842 : entry->oidlist = NIL;
404 : 4842 : entry->finalPath = NIL;
405 : 4842 : entry->firstNS = InvalidOid;
406 : 4842 : entry->temp_missing = false;
407 : 4842 : entry->forceRecompute = false;
408 : : /* do not touch entry->status, used by simplehash */
409 : 4842 : }
410 : :
411 : 8829 : LastSearchPathCacheEntry = entry;
412 : 8829 : return entry;
413 : 8829 : }
414 : 9096 : }
415 : :
416 : : /*
417 : : * RangeVarGetRelidExtended
418 : : * Given a RangeVar describing an existing relation,
419 : : * select the proper namespace and look up the relation OID.
420 : : *
421 : : * If the schema or relation is not found, return InvalidOid if flags contains
422 : : * RVR_MISSING_OK, otherwise raise an error.
423 : : *
424 : : * If flags contains RVR_NOWAIT, throw an error if we'd have to wait for a
425 : : * lock.
426 : : *
427 : : * If flags contains RVR_SKIP_LOCKED, return InvalidOid if we'd have to wait
428 : : * for a lock.
429 : : *
430 : : * flags cannot contain both RVR_NOWAIT and RVR_SKIP_LOCKED.
431 : : *
432 : : * Note that if RVR_MISSING_OK and RVR_SKIP_LOCKED are both specified, a
433 : : * return value of InvalidOid could either mean the relation is missing or it
434 : : * could not be locked.
435 : : *
436 : : * Callback allows caller to check permissions or acquire additional locks
437 : : * prior to grabbing the relation lock.
438 : : */
439 : : Oid
440 : 59588 : RangeVarGetRelidExtended(const RangeVar *relation, LOCKMODE lockmode,
441 : : uint32 flags,
442 : : RangeVarGetRelidCallback callback, void *callback_arg)
443 : : {
444 : 59588 : uint64 inval_count;
445 : 59588 : Oid relId;
446 : 59588 : Oid oldRelId = InvalidOid;
447 : 59588 : bool retry = false;
448 : 59588 : bool missing_ok = (flags & RVR_MISSING_OK) != 0;
449 : :
450 : : /* verify that flags do no conflict */
451 [ + + + - ]: 59588 : Assert(!((flags & RVR_NOWAIT) && (flags & RVR_SKIP_LOCKED)));
452 : :
453 : : /*
454 : : * We check the catalog name and then ignore it.
455 : : */
456 [ + + ]: 59588 : if (relation->catalogname)
457 : : {
458 [ - + ]: 13 : if (strcmp(relation->catalogname, get_database_name(MyDatabaseId)) != 0)
459 [ + - + - ]: 13 : ereport(ERROR,
460 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
461 : : errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
462 : : relation->catalogname, relation->schemaname,
463 : : relation->relname)));
464 : 0 : }
465 : :
466 : : /*
467 : : * DDL operations can change the results of a name lookup. Since all such
468 : : * operations will generate invalidation messages, we keep track of
469 : : * whether any such messages show up while we're performing the operation,
470 : : * and retry until either (1) no more invalidation messages show up or (2)
471 : : * the answer doesn't change.
472 : : *
473 : : * But if lockmode = NoLock, then we assume that either the caller is OK
474 : : * with the answer changing under them, or that they already hold some
475 : : * appropriate lock, and therefore return the first answer we get without
476 : : * checking for invalidation messages. Also, if the requested lock is
477 : : * already held, LockRelationOid will not AcceptInvalidationMessages, so
478 : : * we may fail to notice a change. We could protect against that case by
479 : : * calling AcceptInvalidationMessages() before beginning this loop, but
480 : : * that would add a significant amount overhead, so for now we don't.
481 : : */
482 : 60357 : for (;;)
483 : : {
484 : : /*
485 : : * Remember this value, so that, after looking up the relation name
486 : : * and locking its OID, we can check whether any invalidation messages
487 : : * have been processed that might require a do-over.
488 : : */
489 : 60357 : inval_count = SharedInvalidMessageCounter;
490 : :
491 : : /*
492 : : * Some non-default relpersistence value may have been specified. The
493 : : * parser never generates such a RangeVar in simple DML, but it can
494 : : * happen in contexts such as "CREATE TEMP TABLE foo (f1 int PRIMARY
495 : : * KEY)". Such a command will generate an added CREATE INDEX
496 : : * operation, which must be careful to find the temp table, even when
497 : : * pg_temp is not first in the search path.
498 : : */
499 [ + + ]: 60357 : if (relation->relpersistence == RELPERSISTENCE_TEMP)
500 : : {
501 [ + - ]: 110 : if (!OidIsValid(myTempNamespace))
502 : 0 : relId = InvalidOid; /* this probably can't happen? */
503 : : else
504 : : {
505 [ + + ]: 110 : if (relation->schemaname)
506 : : {
507 : 2 : Oid namespaceId;
508 : :
509 : 2 : namespaceId = LookupExplicitNamespace(relation->schemaname, missing_ok);
510 : :
511 : : /*
512 : : * For missing_ok, allow a non-existent schema name to
513 : : * return InvalidOid.
514 : : */
515 [ + - ]: 2 : if (namespaceId != myTempNamespace)
516 [ # # # # ]: 0 : ereport(ERROR,
517 : : (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
518 : : errmsg("temporary tables cannot specify a schema name")));
519 : 2 : }
520 : :
521 : 110 : relId = get_relname_relid(relation->relname, myTempNamespace);
522 : : }
523 : 110 : }
524 [ + + ]: 60247 : else if (relation->schemaname)
525 : : {
526 : 21089 : Oid namespaceId;
527 : :
528 : : /* use exact schema given */
529 : 21089 : namespaceId = LookupExplicitNamespace(relation->schemaname, missing_ok);
530 [ + + + + ]: 21089 : if (missing_ok && !OidIsValid(namespaceId))
531 : 14 : relId = InvalidOid;
532 : : else
533 : 21075 : relId = get_relname_relid(relation->relname, namespaceId);
534 : 21089 : }
535 : : else
536 : : {
537 : : /* search the namespace path */
538 : 39158 : relId = RelnameGetRelid(relation->relname);
539 : : }
540 : :
541 : : /*
542 : : * Invoke caller-supplied callback, if any.
543 : : *
544 : : * This callback is a good place to check permissions: we haven't
545 : : * taken the table lock yet (and it's really best to check permissions
546 : : * before locking anything!), but we've gotten far enough to know what
547 : : * OID we think we should lock. Of course, concurrent DDL might
548 : : * change things while we're waiting for the lock, but in that case
549 : : * the callback will be invoked again for the new OID.
550 : : */
551 [ + + ]: 60357 : if (callback)
552 : 8192 : callback(relation, relId, oldRelId, callback_arg);
553 : :
554 : : /*
555 : : * If no lock requested, we assume the caller knows what they're
556 : : * doing. They should have already acquired a heavyweight lock on
557 : : * this relation earlier in the processing of this same statement, so
558 : : * it wouldn't be appropriate to AcceptInvalidationMessages() here, as
559 : : * that might pull the rug out from under them.
560 : : */
561 [ + + ]: 60357 : if (lockmode == NoLock)
562 : 1587 : break;
563 : :
564 : : /*
565 : : * If, upon retry, we get back the same OID we did last time, then the
566 : : * invalidation messages we processed did not change the final answer.
567 : : * So we're done.
568 : : *
569 : : * If we got a different OID, we've locked the relation that used to
570 : : * have this name rather than the one that does now. So release the
571 : : * lock.
572 : : */
573 [ + + ]: 58770 : if (retry)
574 : : {
575 [ + - ]: 723 : if (relId == oldRelId)
576 : 723 : break;
577 [ # # ]: 0 : if (OidIsValid(oldRelId))
578 : 0 : UnlockRelationOid(oldRelId, lockmode);
579 : 0 : }
580 : :
581 : : /*
582 : : * Lock relation. This will also accept any pending invalidation
583 : : * messages. If we got back InvalidOid, indicating not found, then
584 : : * there's nothing to lock, but we accept invalidation messages
585 : : * anyway, to flush any negative catcache entries that may be
586 : : * lingering.
587 : : */
588 [ + + ]: 58047 : if (!OidIsValid(relId))
589 : 195 : AcceptInvalidationMessages();
590 [ + + ]: 57852 : else if (!(flags & (RVR_NOWAIT | RVR_SKIP_LOCKED)))
591 : 57780 : LockRelationOid(relId, lockmode);
592 [ + - ]: 72 : else if (!ConditionalLockRelationOid(relId, lockmode))
593 : : {
594 : 0 : int elevel = (flags & RVR_SKIP_LOCKED) ? DEBUG1 : ERROR;
595 : :
596 [ # # ]: 0 : if (relation->schemaname)
597 [ # # # # : 0 : ereport(elevel,
# # # # #
# ]
598 : : (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
599 : : errmsg("could not obtain lock on relation \"%s.%s\"",
600 : : relation->schemaname, relation->relname)));
601 : : else
602 [ # # # # : 0 : ereport(elevel,
# # # # #
# ]
603 : : (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
604 : : errmsg("could not obtain lock on relation \"%s\"",
605 : : relation->relname)));
606 : :
607 : 0 : return InvalidOid;
608 : 0 : }
609 : :
610 : : /*
611 : : * If no invalidation message were processed, we're done!
612 : : */
613 [ + + ]: 58047 : if (inval_count == SharedInvalidMessageCounter)
614 : 57265 : break;
615 : :
616 : : /*
617 : : * Something may have changed. Let's repeat the name lookup, to make
618 : : * sure this name still references the same relation it did
619 : : * previously.
620 : : */
621 : 782 : retry = true;
622 : 782 : oldRelId = relId;
623 : : }
624 : :
625 [ + + ]: 59575 : if (!OidIsValid(relId))
626 : : {
627 : 131 : int elevel = missing_ok ? DEBUG1 : ERROR;
628 : :
629 [ + + ]: 131 : if (relation->schemaname)
630 [ - + # # : 27 : ereport(elevel,
+ + - + #
# ]
631 : : (errcode(ERRCODE_UNDEFINED_TABLE),
632 : : errmsg("relation \"%s.%s\" does not exist",
633 : : relation->schemaname, relation->relname)));
634 : : else
635 [ - + # # : 104 : ereport(elevel,
+ + - + #
# ]
636 : : (errcode(ERRCODE_UNDEFINED_TABLE),
637 : : errmsg("relation \"%s\" does not exist",
638 : : relation->relname)));
639 : 131 : }
640 : 59575 : return relId;
641 : 59575 : }
642 : :
643 : : /*
644 : : * RangeVarGetCreationNamespace
645 : : * Given a RangeVar describing a to-be-created relation,
646 : : * choose which namespace to create it in.
647 : : *
648 : : * Note: calling this may result in a CommandCounterIncrement operation.
649 : : * That will happen on the first request for a temp table in any particular
650 : : * backend run; we will need to either create or clean out the temp schema.
651 : : */
652 : : Oid
653 : 12036 : RangeVarGetCreationNamespace(const RangeVar *newRelation)
654 : : {
655 : 12036 : Oid namespaceId;
656 : :
657 : : /*
658 : : * We check the catalog name and then ignore it.
659 : : */
660 [ + - ]: 12036 : if (newRelation->catalogname)
661 : : {
662 [ # # ]: 0 : if (strcmp(newRelation->catalogname, get_database_name(MyDatabaseId)) != 0)
663 [ # # # # ]: 0 : ereport(ERROR,
664 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
665 : : errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
666 : : newRelation->catalogname, newRelation->schemaname,
667 : : newRelation->relname)));
668 : 0 : }
669 : :
670 [ + + ]: 12036 : if (newRelation->schemaname)
671 : : {
672 : : /* check for pg_temp alias */
673 [ + + ]: 4695 : if (strcmp(newRelation->schemaname, "pg_temp") == 0)
674 : : {
675 : : /* Initialize temp namespace */
676 : 31 : AccessTempTableNamespace(false);
677 : 31 : return myTempNamespace;
678 : : }
679 : : /* use exact schema given */
680 : 4664 : namespaceId = get_namespace_oid(newRelation->schemaname, false);
681 : : /* we do not check for USAGE rights here! */
682 : 4664 : }
683 [ + + ]: 7341 : else if (newRelation->relpersistence == RELPERSISTENCE_TEMP)
684 : : {
685 : : /* Initialize temp namespace */
686 : 1074 : AccessTempTableNamespace(false);
687 : 1074 : return myTempNamespace;
688 : : }
689 : : else
690 : : {
691 : : /* use the default creation namespace */
692 : 6267 : recomputeNamespacePath();
693 [ + + ]: 6267 : if (activeTempCreationPending)
694 : : {
695 : : /* Need to initialize temp namespace */
696 : 2 : AccessTempTableNamespace(true);
697 : 2 : return myTempNamespace;
698 : : }
699 : 6265 : namespaceId = activeCreationNamespace;
700 [ + - ]: 6265 : if (!OidIsValid(namespaceId))
701 [ # # # # ]: 0 : ereport(ERROR,
702 : : (errcode(ERRCODE_UNDEFINED_SCHEMA),
703 : : errmsg("no schema has been selected to create in")));
704 : : }
705 : :
706 : : /* Note: callers will check for CREATE rights when appropriate */
707 : :
708 : 10929 : return namespaceId;
709 : 12036 : }
710 : :
711 : : /*
712 : : * RangeVarGetAndCheckCreationNamespace
713 : : *
714 : : * This function returns the OID of the namespace in which a new relation
715 : : * with a given name should be created. If the user does not have CREATE
716 : : * permission on the target namespace, this function will instead signal
717 : : * an ERROR.
718 : : *
719 : : * If non-NULL, *existing_relation_id is set to the OID of any existing relation
720 : : * with the same name which already exists in that namespace, or to InvalidOid
721 : : * if no such relation exists.
722 : : *
723 : : * If lockmode != NoLock, the specified lock mode is acquired on the existing
724 : : * relation, if any, provided that the current user owns the target relation.
725 : : * However, if lockmode != NoLock and the user does not own the target
726 : : * relation, we throw an ERROR, as we must not try to lock relations the
727 : : * user does not have permissions on.
728 : : *
729 : : * As a side effect, this function acquires AccessShareLock on the target
730 : : * namespace. Without this, the namespace could be dropped before our
731 : : * transaction commits, leaving behind relations with relnamespace pointing
732 : : * to a no-longer-existent namespace.
733 : : *
734 : : * As a further side-effect, if the selected namespace is a temporary namespace,
735 : : * we mark the RangeVar as RELPERSISTENCE_TEMP.
736 : : */
737 : : Oid
738 : 10908 : RangeVarGetAndCheckCreationNamespace(RangeVar *relation,
739 : : LOCKMODE lockmode,
740 : : Oid *existing_relation_id)
741 : : {
742 : 10908 : uint64 inval_count;
743 : 10908 : Oid relid;
744 : 10908 : Oid oldrelid = InvalidOid;
745 : 10908 : Oid nspid;
746 : 10908 : Oid oldnspid = InvalidOid;
747 : 10908 : bool retry = false;
748 : :
749 : : /*
750 : : * We check the catalog name and then ignore it.
751 : : */
752 [ + - ]: 10908 : if (relation->catalogname)
753 : : {
754 [ # # ]: 0 : if (strcmp(relation->catalogname, get_database_name(MyDatabaseId)) != 0)
755 [ # # # # ]: 0 : ereport(ERROR,
756 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
757 : : errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
758 : : relation->catalogname, relation->schemaname,
759 : : relation->relname)));
760 : 0 : }
761 : :
762 : : /*
763 : : * As in RangeVarGetRelidExtended(), we guard against concurrent DDL
764 : : * operations by tracking whether any invalidation messages are processed
765 : : * while we're doing the name lookups and acquiring locks. See comments
766 : : * in that function for a more detailed explanation of this logic.
767 : : */
768 : 11356 : for (;;)
769 : : {
770 : 11356 : AclResult aclresult;
771 : :
772 : 11356 : inval_count = SharedInvalidMessageCounter;
773 : :
774 : : /* Look up creation namespace and check for existing relation. */
775 : 11356 : nspid = RangeVarGetCreationNamespace(relation);
776 [ + - ]: 11356 : Assert(OidIsValid(nspid));
777 [ + + ]: 11356 : if (existing_relation_id != NULL)
778 : 5661 : relid = get_relname_relid(relation->relname, nspid);
779 : : else
780 : 5695 : relid = InvalidOid;
781 : :
782 : : /*
783 : : * In bootstrap processing mode, we don't bother with permissions or
784 : : * locking. Permissions might not be working yet, and locking is
785 : : * unnecessary.
786 : : */
787 [ + - ]: 11356 : if (IsBootstrapProcessingMode())
788 : 0 : break;
789 : :
790 : : /* Check namespace permissions. */
791 : 11356 : aclresult = object_aclcheck(NamespaceRelationId, nspid, GetUserId(), ACL_CREATE);
792 [ + - ]: 11356 : if (aclresult != ACLCHECK_OK)
793 : 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
794 : 0 : get_namespace_name(nspid));
795 : :
796 [ + + ]: 11356 : if (retry)
797 : : {
798 : : /* If nothing changed, we're done. */
799 [ + - - + ]: 448 : if (relid == oldrelid && nspid == oldnspid)
800 : 448 : break;
801 : : /* If creation namespace has changed, give up old lock. */
802 [ # # ]: 0 : if (nspid != oldnspid)
803 : 0 : UnlockDatabaseObject(NamespaceRelationId, oldnspid, 0,
804 : : AccessShareLock);
805 : : /* If name points to something different, give up old lock. */
806 [ # # # # : 0 : if (relid != oldrelid && OidIsValid(oldrelid) && lockmode != NoLock)
# # ]
807 : 0 : UnlockRelationOid(oldrelid, lockmode);
808 : 0 : }
809 : :
810 : : /* Lock namespace. */
811 [ - + ]: 10908 : if (nspid != oldnspid)
812 : 10908 : LockDatabaseObject(NamespaceRelationId, nspid, 0, AccessShareLock);
813 : :
814 : : /* Lock relation, if required if and we have permission. */
815 [ + + + + ]: 10908 : if (lockmode != NoLock && OidIsValid(relid))
816 : : {
817 [ + - ]: 36 : if (!object_ownercheck(RelationRelationId, relid, GetUserId()))
818 : 0 : aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(relid)),
819 : 0 : relation->relname);
820 [ - + ]: 36 : if (relid != oldrelid)
821 : 36 : LockRelationOid(relid, lockmode);
822 : 36 : }
823 : :
824 : : /* If no invalidation message were processed, we're done! */
825 [ + + ]: 10908 : if (inval_count == SharedInvalidMessageCounter)
826 : 10460 : break;
827 : :
828 : : /* Something may have changed, so recheck our work. */
829 : 448 : retry = true;
830 : 448 : oldrelid = relid;
831 : 448 : oldnspid = nspid;
832 [ + - + ]: 11356 : }
833 : :
834 : 10908 : RangeVarAdjustRelationPersistence(relation, nspid);
835 [ + + ]: 10908 : if (existing_relation_id != NULL)
836 : 5281 : *existing_relation_id = relid;
837 : 21816 : return nspid;
838 : 10908 : }
839 : :
840 : : /*
841 : : * Adjust the relpersistence for an about-to-be-created relation based on the
842 : : * creation namespace, and throw an error for invalid combinations.
843 : : */
844 : : void
845 : 11152 : RangeVarAdjustRelationPersistence(RangeVar *newRelation, Oid nspid)
846 : : {
847 [ + + + ]: 11152 : switch (newRelation->relpersistence)
848 : : {
849 : : case RELPERSISTENCE_TEMP:
850 [ + + ]: 1009 : if (!isTempOrTempToastNamespace(nspid))
851 : : {
852 [ - + ]: 3 : if (isAnyTempNamespace(nspid))
853 [ # # # # ]: 0 : ereport(ERROR,
854 : : (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
855 : : errmsg("cannot create relations in temporary schemas of other sessions")));
856 : : else
857 [ + - + - ]: 3 : ereport(ERROR,
858 : : (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
859 : : errmsg("cannot create temporary relation in non-temporary schema")));
860 : 0 : }
861 : 1006 : break;
862 : : case RELPERSISTENCE_PERMANENT:
863 [ + + ]: 10102 : if (isTempOrTempToastNamespace(nspid))
864 : 15 : newRelation->relpersistence = RELPERSISTENCE_TEMP;
865 [ + - ]: 10087 : else if (isAnyTempNamespace(nspid))
866 [ # # # # ]: 0 : ereport(ERROR,
867 : : (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
868 : : errmsg("cannot create relations in temporary schemas of other sessions")));
869 : 10102 : break;
870 : : default:
871 [ + + ]: 41 : if (isAnyTempNamespace(nspid))
872 [ + - + - ]: 1 : ereport(ERROR,
873 : : (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
874 : : errmsg("only temporary relations may be created in temporary schemas")));
875 : 40 : }
876 : 11148 : }
877 : :
878 : : /*
879 : : * RelnameGetRelid
880 : : * Try to resolve an unqualified relation name.
881 : : * Returns OID if relation found in search path, else InvalidOid.
882 : : */
883 : : Oid
884 : 39167 : RelnameGetRelid(const char *relname)
885 : : {
886 : 39167 : Oid relid;
887 : 39167 : ListCell *l;
888 : :
889 : 39167 : recomputeNamespacePath();
890 : :
891 [ + - + + : 121885 : foreach(l, activeSearchPath)
+ + + + ]
892 : : {
893 : 82718 : Oid namespaceId = lfirst_oid(l);
894 : :
895 : 82718 : relid = get_relname_relid(relname, namespaceId);
896 [ + + ]: 82718 : if (OidIsValid(relid))
897 : 38996 : return relid;
898 [ + + ]: 82718 : }
899 : :
900 : : /* Not found in path */
901 : 171 : return InvalidOid;
902 : 39167 : }
903 : :
904 : :
905 : : /*
906 : : * RelationIsVisible
907 : : * Determine whether a relation (identified by OID) is visible in the
908 : : * current search path. Visible means "would be found by searching
909 : : * for the unqualified relation name".
910 : : */
911 : : bool
912 : 46315 : RelationIsVisible(Oid relid)
913 : : {
914 : 46315 : return RelationIsVisibleExt(relid, NULL);
915 : : }
916 : :
917 : : /*
918 : : * RelationIsVisibleExt
919 : : * As above, but if the relation isn't found and is_missing is not NULL,
920 : : * then set *is_missing = true and return false instead of throwing
921 : : * an error. (Caller must initialize *is_missing = false.)
922 : : */
923 : : static bool
924 : 50123 : RelationIsVisibleExt(Oid relid, bool *is_missing)
925 : : {
926 : 50123 : HeapTuple reltup;
927 : 50123 : Form_pg_class relform;
928 : 50123 : Oid relnamespace;
929 : 50123 : bool visible;
930 : :
931 : 50123 : reltup = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
932 [ + + ]: 50123 : if (!HeapTupleIsValid(reltup))
933 : : {
934 [ + - ]: 1 : if (is_missing != NULL)
935 : : {
936 : 1 : *is_missing = true;
937 : 1 : return false;
938 : : }
939 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for relation %u", relid);
940 : 0 : }
941 : 50122 : relform = (Form_pg_class) GETSTRUCT(reltup);
942 : :
943 : 50122 : recomputeNamespacePath();
944 : :
945 : : /*
946 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
947 : : * the system namespace are surely in the path and so we needn't even do
948 : : * list_member_oid() for them.
949 : : */
950 : 50122 : relnamespace = relform->relnamespace;
951 [ + + + + ]: 50122 : if (relnamespace != PG_CATALOG_NAMESPACE &&
952 : 41057 : !list_member_oid(activeSearchPath, relnamespace))
953 : 17223 : visible = false;
954 : : else
955 : : {
956 : : /*
957 : : * If it is in the path, it might still not be visible; it could be
958 : : * hidden by another relation of the same name earlier in the path. So
959 : : * we must do a slow check for conflicting relations.
960 : : */
961 : 32899 : char *relname = NameStr(relform->relname);
962 : 32899 : ListCell *l;
963 : :
964 : 32899 : visible = false;
965 [ + - - + : 115037 : foreach(l, activeSearchPath)
+ - ]
966 : : {
967 : 82138 : Oid namespaceId = lfirst_oid(l);
968 : :
969 [ + + ]: 82138 : if (namespaceId == relnamespace)
970 : : {
971 : : /* Found it first in path */
972 : 32888 : visible = true;
973 : 32888 : break;
974 : : }
975 [ + + ]: 49250 : if (OidIsValid(get_relname_relid(relname, namespaceId)))
976 : : {
977 : : /* Found something else first in path */
978 : 11 : break;
979 : : }
980 [ + + ]: 82138 : }
981 : 32899 : }
982 : :
983 : 50122 : ReleaseSysCache(reltup);
984 : :
985 : 50122 : return visible;
986 : 50123 : }
987 : :
988 : :
989 : : /*
990 : : * TypenameGetTypid
991 : : * Wrapper for binary compatibility.
992 : : */
993 : : Oid
994 : 0 : TypenameGetTypid(const char *typname)
995 : : {
996 : 0 : return TypenameGetTypidExtended(typname, true);
997 : : }
998 : :
999 : : /*
1000 : : * TypenameGetTypidExtended
1001 : : * Try to resolve an unqualified datatype name.
1002 : : * Returns OID if type found in search path, else InvalidOid.
1003 : : *
1004 : : * This is essentially the same as RelnameGetRelid.
1005 : : */
1006 : : Oid
1007 : 25427 : TypenameGetTypidExtended(const char *typname, bool temp_ok)
1008 : : {
1009 : 25427 : Oid typid;
1010 : 25427 : ListCell *l;
1011 : :
1012 : 25427 : recomputeNamespacePath();
1013 : :
1014 [ + - + + : 67355 : foreach(l, activeSearchPath)
+ + + + ]
1015 : : {
1016 : 41928 : Oid namespaceId = lfirst_oid(l);
1017 : :
1018 [ + + + + ]: 41928 : if (!temp_ok && namespaceId == myTempNamespace)
1019 : 1566 : continue; /* do not look in temp namespace */
1020 : :
1021 : 40362 : typid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
1022 : : PointerGetDatum(typname),
1023 : : ObjectIdGetDatum(namespaceId));
1024 [ + + ]: 40362 : if (OidIsValid(typid))
1025 : 20870 : return typid;
1026 [ + + + ]: 41928 : }
1027 : :
1028 : : /* Not found in path */
1029 : 4557 : return InvalidOid;
1030 : 25427 : }
1031 : :
1032 : : /*
1033 : : * TypeIsVisible
1034 : : * Determine whether a type (identified by OID) is visible in the
1035 : : * current search path. Visible means "would be found by searching
1036 : : * for the unqualified type name".
1037 : : */
1038 : : bool
1039 : 19225 : TypeIsVisible(Oid typid)
1040 : : {
1041 : 19225 : return TypeIsVisibleExt(typid, NULL);
1042 : : }
1043 : :
1044 : : /*
1045 : : * TypeIsVisibleExt
1046 : : * As above, but if the type isn't found and is_missing is not NULL,
1047 : : * then set *is_missing = true and return false instead of throwing
1048 : : * an error. (Caller must initialize *is_missing = false.)
1049 : : */
1050 : : static bool
1051 : 19261 : TypeIsVisibleExt(Oid typid, bool *is_missing)
1052 : : {
1053 : 19261 : HeapTuple typtup;
1054 : 19261 : Form_pg_type typform;
1055 : 19261 : Oid typnamespace;
1056 : 19261 : bool visible;
1057 : :
1058 : 19261 : typtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
1059 [ + - ]: 19261 : if (!HeapTupleIsValid(typtup))
1060 : : {
1061 [ # # ]: 0 : if (is_missing != NULL)
1062 : : {
1063 : 0 : *is_missing = true;
1064 : 0 : return false;
1065 : : }
1066 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for type %u", typid);
1067 : 0 : }
1068 : 19261 : typform = (Form_pg_type) GETSTRUCT(typtup);
1069 : :
1070 : 19261 : recomputeNamespacePath();
1071 : :
1072 : : /*
1073 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
1074 : : * the system namespace are surely in the path and so we needn't even do
1075 : : * list_member_oid() for them.
1076 : : */
1077 : 19261 : typnamespace = typform->typnamespace;
1078 [ + + + + ]: 19261 : if (typnamespace != PG_CATALOG_NAMESPACE &&
1079 : 12191 : !list_member_oid(activeSearchPath, typnamespace))
1080 : 1946 : visible = false;
1081 : : else
1082 : : {
1083 : : /*
1084 : : * If it is in the path, it might still not be visible; it could be
1085 : : * hidden by another type of the same name earlier in the path. So we
1086 : : * must do a slow check for conflicting types.
1087 : : */
1088 : 17315 : char *typname = NameStr(typform->typname);
1089 : 17315 : ListCell *l;
1090 : :
1091 : 17315 : visible = false;
1092 [ + - - + : 53838 : foreach(l, activeSearchPath)
+ - ]
1093 : : {
1094 : 36523 : Oid namespaceId = lfirst_oid(l);
1095 : :
1096 [ + + ]: 36523 : if (namespaceId == typnamespace)
1097 : : {
1098 : : /* Found it first in path */
1099 : 17313 : visible = true;
1100 : 17313 : break;
1101 : : }
1102 [ + + ]: 19210 : if (SearchSysCacheExists2(TYPENAMENSP,
1103 : : PointerGetDatum(typname),
1104 : : ObjectIdGetDatum(namespaceId)))
1105 : : {
1106 : : /* Found something else first in path */
1107 : 2 : break;
1108 : : }
1109 [ + + ]: 36523 : }
1110 : 17315 : }
1111 : :
1112 : 19261 : ReleaseSysCache(typtup);
1113 : :
1114 : 19261 : return visible;
1115 : 19261 : }
1116 : :
1117 : :
1118 : : /*
1119 : : * FuncnameGetCandidates
1120 : : * Given a possibly-qualified routine name, argument count, and arg names,
1121 : : * retrieve a list of the possible matches.
1122 : : *
1123 : : * If nargs is -1, we return all routines matching the given name,
1124 : : * regardless of argument count. (argnames must be NIL, and expand_variadic
1125 : : * and expand_defaults must be false, in this case.)
1126 : : *
1127 : : * If argnames isn't NIL, we are considering a named- or mixed-notation call,
1128 : : * and only routines having all the listed argument names will be returned.
1129 : : * (We assume that length(argnames) <= nargs and all the passed-in names are
1130 : : * distinct.) The returned structs will include an argnumbers array showing
1131 : : * the actual argument index for each logical argument position.
1132 : : *
1133 : : * If expand_variadic is true, then variadic functions having the same number
1134 : : * or fewer arguments will be retrieved, with the variadic argument and any
1135 : : * additional argument positions filled with the variadic element type.
1136 : : * nvargs in the returned struct is set to the number of such arguments.
1137 : : * If expand_variadic is false, variadic arguments are not treated specially,
1138 : : * and the returned nvargs will always be zero.
1139 : : *
1140 : : * If expand_defaults is true, functions that could match after insertion of
1141 : : * default argument values will also be retrieved. In this case the returned
1142 : : * structs could have nargs > passed-in nargs, and ndargs is set to the number
1143 : : * of additional args (which can be retrieved from the function's
1144 : : * proargdefaults entry).
1145 : : *
1146 : : * If include_out_arguments is true, then OUT-mode arguments are considered to
1147 : : * be included in the argument list. Their types are included in the returned
1148 : : * arrays, and argnumbers are indexes in proallargtypes not proargtypes.
1149 : : * We also set nominalnargs to be the length of proallargtypes not proargtypes.
1150 : : * Otherwise OUT-mode arguments are ignored.
1151 : : *
1152 : : * It is not possible for nvargs and ndargs to both be nonzero in the same
1153 : : * list entry, since default insertion allows matches to functions with more
1154 : : * than nargs arguments while the variadic transformation requires the same
1155 : : * number or less.
1156 : : *
1157 : : * When argnames isn't NIL, the returned args[] type arrays are not ordered
1158 : : * according to the functions' declarations, but rather according to the call:
1159 : : * first any positional arguments, then the named arguments, then defaulted
1160 : : * arguments (if needed and allowed by expand_defaults). The argnumbers[]
1161 : : * array can be used to map this back to the catalog information.
1162 : : * argnumbers[k] is set to the proargtypes or proallargtypes index of the
1163 : : * k'th call argument.
1164 : : *
1165 : : * We search a single namespace if the function name is qualified, else
1166 : : * all namespaces in the search path. In the multiple-namespace case,
1167 : : * we arrange for entries in earlier namespaces to mask identical entries in
1168 : : * later namespaces.
1169 : : *
1170 : : * When expanding variadics, we arrange for non-variadic functions to mask
1171 : : * variadic ones if the expanded argument list is the same. It is still
1172 : : * possible for there to be conflicts between different variadic functions,
1173 : : * however.
1174 : : *
1175 : : * It is guaranteed that the return list will never contain multiple entries
1176 : : * with identical argument lists. When expand_defaults is true, the entries
1177 : : * could have more than nargs positions, but we still guarantee that they are
1178 : : * distinct in the first nargs positions. However, if argnames isn't NIL or
1179 : : * either expand_variadic or expand_defaults is true, there might be multiple
1180 : : * candidate functions that expand to identical argument lists. Rather than
1181 : : * throw error here, we report such situations by returning a single entry
1182 : : * with oid = 0 that represents a set of such conflicting candidates.
1183 : : * The caller might end up discarding such an entry anyway, but if it selects
1184 : : * such an entry it should react as though the call were ambiguous.
1185 : : *
1186 : : * We return an empty list (NULL) if no suitable matches can be found.
1187 : : * If the function name was schema-qualified with a schema that does not
1188 : : * exist, then we return an empty list if missing_ok is true and otherwise
1189 : : * throw an error. (missing_ok does not affect the behavior otherwise.)
1190 : : *
1191 : : * The output argument *fgc_flags is filled with a bitmask indicating how
1192 : : * far we were able to match the supplied information. This is not of much
1193 : : * interest if any candidates were found, but if not, it can help callers
1194 : : * produce an on-point error message.
1195 : : */
1196 : : FuncCandidateList
1197 : 40525 : FuncnameGetCandidates(List *names, int nargs, List *argnames,
1198 : : bool expand_variadic, bool expand_defaults,
1199 : : bool include_out_arguments, bool missing_ok,
1200 : : int *fgc_flags)
1201 : : {
1202 : 40525 : FuncCandidateList resultList = NULL;
1203 : 40525 : bool any_special = false;
1204 : 40525 : char *schemaname;
1205 : 40525 : char *funcname;
1206 : 40525 : Oid namespaceId;
1207 : 40525 : CatCList *catlist;
1208 : 40525 : int i;
1209 : :
1210 : : /* check for caller error */
1211 [ + + + - ]: 40525 : Assert(nargs >= 0 || !(expand_variadic | expand_defaults));
1212 : :
1213 : : /* initialize output fgc_flags to empty */
1214 : 40525 : *fgc_flags = 0;
1215 : :
1216 : : /* deconstruct the name list */
1217 : 40525 : DeconstructQualifiedName(names, &schemaname, &funcname);
1218 : :
1219 [ + + ]: 40525 : if (schemaname)
1220 : : {
1221 : : /* use exact schema given */
1222 : 14507 : *fgc_flags |= FGC_SCHEMA_GIVEN; /* report that a schema is given */
1223 : 14507 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
1224 [ + + ]: 14507 : if (!OidIsValid(namespaceId))
1225 : 8 : return NULL;
1226 : 14499 : *fgc_flags |= FGC_SCHEMA_EXISTS; /* report that the schema exists */
1227 : 14499 : }
1228 : : else
1229 : : {
1230 : : /* flag to indicate we need namespace search */
1231 : 26018 : namespaceId = InvalidOid;
1232 : 26018 : recomputeNamespacePath();
1233 : : }
1234 : :
1235 : : /* Search syscache by name only */
1236 : 40517 : catlist = SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(funcname));
1237 : :
1238 [ + + ]: 143910 : for (i = 0; i < catlist->n_members; i++)
1239 : : {
1240 : 103393 : HeapTuple proctup = &catlist->members[i]->tuple;
1241 : 103393 : Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
1242 : 103393 : Oid *proargtypes = procform->proargtypes.values;
1243 : 103393 : int pronargs = procform->pronargs;
1244 : 103393 : int effective_nargs;
1245 : 103393 : int pathpos = 0;
1246 : 103393 : bool variadic;
1247 : 103393 : bool use_defaults;
1248 : 103393 : Oid va_elem_type;
1249 : 103393 : int *argnumbers = NULL;
1250 : 103393 : FuncCandidateList newResult;
1251 : :
1252 : 103393 : *fgc_flags |= FGC_NAME_EXISTS; /* the name is present in pg_proc */
1253 : :
1254 [ + + ]: 103393 : if (OidIsValid(namespaceId))
1255 : : {
1256 : : /* Consider only procs in specified namespace */
1257 [ + + ]: 28294 : if (procform->pronamespace != namespaceId)
1258 : 1 : continue;
1259 : 28293 : }
1260 : : else
1261 : : {
1262 : : /*
1263 : : * Consider only procs that are in the search path and are not in
1264 : : * the temp namespace.
1265 : : */
1266 : 75099 : ListCell *nsp;
1267 : :
1268 [ + - + + : 184478 : foreach(nsp, activeSearchPath)
+ + ]
1269 : : {
1270 [ + + + + ]: 109379 : if (procform->pronamespace == lfirst_oid(nsp) &&
1271 : 75069 : procform->pronamespace != myTempNamespace)
1272 : 75064 : break;
1273 : 34315 : pathpos++;
1274 : 34315 : }
1275 [ + + ]: 75099 : if (nsp == NULL)
1276 : 35 : continue; /* proc is not in search path */
1277 [ + + ]: 75099 : }
1278 : :
1279 : 103357 : *fgc_flags |= FGC_NAME_VISIBLE; /* routine is in the right schema */
1280 : :
1281 : : /*
1282 : : * If we are asked to match to OUT arguments, then use the
1283 : : * proallargtypes array (which includes those); otherwise use
1284 : : * proargtypes (which doesn't). Of course, if proallargtypes is null,
1285 : : * we always use proargtypes.
1286 : : */
1287 [ + + ]: 103357 : if (include_out_arguments)
1288 : : {
1289 : 79 : Datum proallargtypes;
1290 : 79 : bool isNull;
1291 : :
1292 : 79 : proallargtypes = SysCacheGetAttr(PROCNAMEARGSNSP, proctup,
1293 : : Anum_pg_proc_proallargtypes,
1294 : : &isNull);
1295 [ + + ]: 79 : if (!isNull)
1296 : : {
1297 : 20 : ArrayType *arr = DatumGetArrayTypeP(proallargtypes);
1298 : :
1299 : 20 : pronargs = ARR_DIMS(arr)[0];
1300 [ + - ]: 20 : if (ARR_NDIM(arr) != 1 ||
1301 : 20 : pronargs < 0 ||
1302 : 20 : ARR_HASNULL(arr) ||
1303 : 20 : ARR_ELEMTYPE(arr) != OIDOID)
1304 [ # # # # ]: 0 : elog(ERROR, "proallargtypes is not a 1-D Oid array or it contains nulls");
1305 [ + - ]: 20 : Assert(pronargs >= procform->pronargs);
1306 [ - + ]: 20 : proargtypes = (Oid *) ARR_DATA_PTR(arr);
1307 : 20 : }
1308 : 79 : }
1309 : :
1310 [ + + ]: 103357 : if (argnames != NIL)
1311 : : {
1312 : : /*
1313 : : * Call uses named or mixed notation
1314 : : *
1315 : : * Check argument count.
1316 : : */
1317 [ + - ]: 210 : Assert(nargs >= 0); /* -1 not supported with argnames */
1318 : :
1319 [ + + - + ]: 210 : if (pronargs > nargs && expand_defaults)
1320 : : {
1321 : : /* Ignore if not enough default expressions */
1322 [ - + ]: 145 : if (nargs + procform->pronargdefaults < pronargs)
1323 : 0 : continue;
1324 : 145 : use_defaults = true;
1325 : 145 : }
1326 : : else
1327 : 65 : use_defaults = false;
1328 : :
1329 : : /* Ignore if it doesn't match requested argument count */
1330 [ + + + + ]: 210 : if (pronargs != nargs && !use_defaults)
1331 : 2 : continue;
1332 : :
1333 : : /* We found a routine with a suitable number of arguments */
1334 : 208 : *fgc_flags |= FGC_ARGCOUNT_MATCH;
1335 : :
1336 : : /* Check for argument name match, generate positional mapping */
1337 [ + + + + ]: 416 : if (!MatchNamedCall(proctup, nargs, argnames,
1338 : 208 : include_out_arguments, pronargs,
1339 : 208 : &argnumbers, fgc_flags))
1340 : 5 : continue;
1341 : :
1342 : : /*
1343 : : * Named or mixed notation can match a variadic function only if
1344 : : * expand_variadic is off; otherwise there is no way to match the
1345 : : * presumed-nameless parameters expanded from the variadic array.
1346 : : * However, we postpone the check until here because we want to
1347 : : * perform argument name matching anyway (using the variadic array
1348 : : * argument's name). This allows us to give an on-point error
1349 : : * message if the user forgets to say VARIADIC in what would have
1350 : : * been a valid call with it.
1351 : : */
1352 [ + + + + ]: 203 : if (OidIsValid(procform->provariadic) && expand_variadic)
1353 : 1 : continue;
1354 : 202 : va_elem_type = InvalidOid;
1355 : 202 : variadic = false;
1356 : :
1357 : : /* We found a fully-valid call using argument names */
1358 : 202 : *fgc_flags |= FGC_ARGNAMES_VALID;
1359 : :
1360 : : /* Named argument matching is always "special" */
1361 : 202 : any_special = true;
1362 : 202 : }
1363 : : else
1364 : : {
1365 : : /*
1366 : : * Call uses positional notation
1367 : : *
1368 : : * Check if function is variadic, and get variadic element type if
1369 : : * so. If expand_variadic is false, we should just ignore
1370 : : * variadic-ness.
1371 : : */
1372 [ + + + + ]: 103147 : if (pronargs <= nargs && expand_variadic)
1373 : : {
1374 : 76881 : va_elem_type = procform->provariadic;
1375 : 76881 : variadic = OidIsValid(va_elem_type);
1376 : 76881 : any_special |= variadic;
1377 : 76881 : }
1378 : : else
1379 : : {
1380 : 26266 : va_elem_type = InvalidOid;
1381 : 26266 : variadic = false;
1382 : : }
1383 : :
1384 : : /*
1385 : : * Check if function can match by using parameter defaults.
1386 : : */
1387 [ + + + + ]: 103147 : if (pronargs > nargs && expand_defaults)
1388 : : {
1389 : : /* Ignore if not enough default expressions */
1390 [ + + ]: 20648 : if (nargs + procform->pronargdefaults < pronargs)
1391 : 19784 : continue;
1392 : 864 : use_defaults = true;
1393 : 864 : any_special = true;
1394 : 864 : }
1395 : : else
1396 : 82499 : use_defaults = false;
1397 : :
1398 : : /* Ignore if it doesn't match requested argument count */
1399 [ + + + + : 83363 : if (nargs >= 0 && pronargs != nargs && !variadic && !use_defaults)
+ + + + ]
1400 : 7674 : continue;
1401 : :
1402 : : /* We found a routine with a suitable number of arguments */
1403 : 75689 : *fgc_flags |= FGC_ARGCOUNT_MATCH;
1404 : : }
1405 : :
1406 : : /*
1407 : : * We must compute the effective argument list so that we can easily
1408 : : * compare it to earlier results. We waste a palloc cycle if it gets
1409 : : * masked by an earlier result, but really that's a pretty infrequent
1410 : : * case so it's not worth worrying about.
1411 : : */
1412 [ + + ]: 75891 : effective_nargs = Max(pronargs, nargs);
1413 : 75891 : newResult = (FuncCandidateList)
1414 : 75891 : palloc(offsetof(struct _FuncCandidateList, args) +
1415 : 75891 : effective_nargs * sizeof(Oid));
1416 : 75891 : newResult->pathpos = pathpos;
1417 : 75891 : newResult->oid = procform->oid;
1418 : 75891 : newResult->nominalnargs = pronargs;
1419 : 75891 : newResult->nargs = effective_nargs;
1420 : 75891 : newResult->argnumbers = argnumbers;
1421 [ + + ]: 75891 : if (argnumbers)
1422 : : {
1423 : : /* Re-order the argument types into call's logical order */
1424 [ + + ]: 1008 : for (int j = 0; j < pronargs; j++)
1425 : 806 : newResult->args[j] = proargtypes[argnumbers[j]];
1426 : 202 : }
1427 : : else
1428 : : {
1429 : : /* Simple positional case, just copy proargtypes as-is */
1430 : 75689 : memcpy(newResult->args, proargtypes, pronargs * sizeof(Oid));
1431 : : }
1432 [ + + ]: 75891 : if (variadic)
1433 : : {
1434 : 1073 : newResult->nvargs = effective_nargs - pronargs + 1;
1435 : : /* Expand variadic argument into N copies of element type */
1436 [ + + ]: 3549 : for (int j = pronargs - 1; j < effective_nargs; j++)
1437 : 2476 : newResult->args[j] = va_elem_type;
1438 : 1073 : }
1439 : : else
1440 : 74818 : newResult->nvargs = 0;
1441 [ + + ]: 75891 : newResult->ndargs = use_defaults ? pronargs - nargs : 0;
1442 : :
1443 : : /*
1444 : : * Does it have the same arguments as something we already accepted?
1445 : : * If so, decide what to do to avoid returning duplicate argument
1446 : : * lists. We can skip this check for the single-namespace case if no
1447 : : * special (named, variadic or defaults) match has been made, since
1448 : : * then the unique index on pg_proc guarantees all the matches have
1449 : : * different argument lists.
1450 : : */
1451 [ + + + + ]: 111037 : if (resultList != NULL &&
1452 [ + + ]: 35549 : (any_special || !OidIsValid(namespaceId)))
1453 : : {
1454 : : /*
1455 : : * If we have an ordered list from SearchSysCacheList (the normal
1456 : : * case), then any conflicting proc must immediately adjoin this
1457 : : * one in the list, so we only need to look at the newest result
1458 : : * item. If we have an unordered list, we have to scan the whole
1459 : : * result list. Also, if either the current candidate or any
1460 : : * previous candidate is a special match, we can't assume that
1461 : : * conflicts are adjacent.
1462 : : *
1463 : : * We ignore defaulted arguments in deciding what is a match.
1464 : : */
1465 : 31534 : FuncCandidateList prevResult;
1466 : :
1467 [ + - + + ]: 31534 : if (catlist->ordered && !any_special)
1468 : : {
1469 : : /* ndargs must be 0 if !any_special */
1470 [ + + + + ]: 31131 : if (effective_nargs == resultList->nargs &&
1471 : 62260 : memcmp(newResult->args,
1472 : 31130 : resultList->args,
1473 : 62260 : effective_nargs * sizeof(Oid)) == 0)
1474 : 1 : prevResult = resultList;
1475 : : else
1476 : 31130 : prevResult = NULL;
1477 : 31131 : }
1478 : : else
1479 : : {
1480 : 403 : int cmp_nargs = newResult->nargs - newResult->ndargs;
1481 : :
1482 [ + + ]: 439 : for (prevResult = resultList;
1483 : 439 : prevResult;
1484 : 36 : prevResult = prevResult->next)
1485 : : {
1486 [ + - + + ]: 423 : if (cmp_nargs == prevResult->nargs - prevResult->ndargs &&
1487 : 846 : memcmp(newResult->args,
1488 : 423 : prevResult->args,
1489 : 846 : cmp_nargs * sizeof(Oid)) == 0)
1490 : 387 : break;
1491 : 36 : }
1492 : 403 : }
1493 : :
1494 [ + + ]: 31534 : if (prevResult)
1495 : : {
1496 : : /*
1497 : : * We have a match with a previous result. Decide which one
1498 : : * to keep, or mark it ambiguous if we can't decide. The
1499 : : * logic here is preference > 0 means prefer the old result,
1500 : : * preference < 0 means prefer the new, preference = 0 means
1501 : : * ambiguous.
1502 : : */
1503 : 388 : int preference;
1504 : :
1505 [ - + ]: 388 : if (pathpos != prevResult->pathpos)
1506 : : {
1507 : : /*
1508 : : * Prefer the one that's earlier in the search path.
1509 : : */
1510 : 0 : preference = pathpos - prevResult->pathpos;
1511 : 0 : }
1512 [ + + - + ]: 388 : else if (variadic && prevResult->nvargs == 0)
1513 : : {
1514 : : /*
1515 : : * With variadic functions we could have, for example,
1516 : : * both foo(numeric) and foo(variadic numeric[]) in the
1517 : : * same namespace; if so we prefer the non-variadic match
1518 : : * on efficiency grounds.
1519 : : */
1520 : 368 : preference = 1;
1521 : 368 : }
1522 [ + - + + ]: 20 : else if (!variadic && prevResult->nvargs > 0)
1523 : : {
1524 : 13 : preference = -1;
1525 : 13 : }
1526 : : else
1527 : : {
1528 : : /*----------
1529 : : * We can't decide. This can happen with, for example,
1530 : : * both foo(numeric, variadic numeric[]) and
1531 : : * foo(variadic numeric[]) in the same namespace, or
1532 : : * both foo(int) and foo (int, int default something)
1533 : : * in the same namespace, or both foo(a int, b text)
1534 : : * and foo(b text, a int) in the same namespace.
1535 : : *----------
1536 : : */
1537 : 7 : preference = 0;
1538 : : }
1539 : :
1540 [ + + ]: 388 : if (preference > 0)
1541 : : {
1542 : : /* keep previous result */
1543 : 368 : pfree(newResult);
1544 : 368 : continue;
1545 : : }
1546 [ + + ]: 20 : else if (preference < 0)
1547 : : {
1548 : : /* remove previous result from the list */
1549 [ - + ]: 13 : if (prevResult == resultList)
1550 : 13 : resultList = prevResult->next;
1551 : : else
1552 : : {
1553 : 0 : FuncCandidateList prevPrevResult;
1554 : :
1555 [ # # ]: 0 : for (prevPrevResult = resultList;
1556 : 0 : prevPrevResult;
1557 : 0 : prevPrevResult = prevPrevResult->next)
1558 : : {
1559 [ # # ]: 0 : if (prevResult == prevPrevResult->next)
1560 : : {
1561 : 0 : prevPrevResult->next = prevResult->next;
1562 : 0 : break;
1563 : : }
1564 : 0 : }
1565 [ # # ]: 0 : Assert(prevPrevResult); /* assert we found it */
1566 : 0 : }
1567 : 13 : pfree(prevResult);
1568 : : /* fall through to add newResult to list */
1569 : 13 : }
1570 : : else
1571 : : {
1572 : : /* mark old result as ambiguous, discard new */
1573 : 7 : prevResult->oid = InvalidOid;
1574 : 7 : pfree(newResult);
1575 : 7 : continue;
1576 : : }
1577 [ + + ]: 388 : }
1578 [ + + ]: 31534 : }
1579 : :
1580 : : /*
1581 : : * Okay to add it to result list
1582 : : */
1583 : 75516 : newResult->next = resultList;
1584 : 75516 : resultList = newResult;
1585 [ - + + ]: 103393 : }
1586 : :
1587 : 40517 : ReleaseSysCacheList(catlist);
1588 : :
1589 : 40517 : return resultList;
1590 : 40525 : }
1591 : :
1592 : : /*
1593 : : * MatchNamedCall
1594 : : * Given a pg_proc heap tuple and a call's list of argument names,
1595 : : * check whether the function could match the call.
1596 : : *
1597 : : * The call could match if all supplied argument names are accepted by
1598 : : * the function, in positions after the last positional argument, and there
1599 : : * are defaults for all unsupplied arguments.
1600 : : *
1601 : : * If include_out_arguments is true, we are treating OUT arguments as
1602 : : * included in the argument list. pronargs is the number of arguments
1603 : : * we're considering (the length of either proargtypes or proallargtypes).
1604 : : *
1605 : : * The number of positional arguments is nargs - list_length(argnames).
1606 : : * Note caller has already done basic checks on argument count.
1607 : : *
1608 : : * On match, return true and fill *argnumbers with a palloc'd array showing
1609 : : * the mapping from call argument positions to actual function argument
1610 : : * numbers. Defaulted arguments are included in this map, at positions
1611 : : * after the last supplied argument.
1612 : : *
1613 : : * We also add flag bits to *fgc_flags reporting on how far the match got.
1614 : : */
1615 : : static bool
1616 : 208 : MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
1617 : : bool include_out_arguments, int pronargs,
1618 : : int **argnumbers, int *fgc_flags)
1619 : : {
1620 : 208 : Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
1621 : 208 : int numposargs = nargs - list_length(argnames);
1622 : 208 : int pronallargs;
1623 : 208 : Oid *p_argtypes;
1624 : 208 : char **p_argnames;
1625 : 208 : char *p_argmodes;
1626 : 208 : bool arggiven[FUNC_MAX_ARGS];
1627 : 208 : bool arg_filled_twice = false;
1628 : 208 : bool isnull;
1629 : 208 : int ap; /* call args position */
1630 : 208 : int pp; /* proargs position */
1631 : 208 : ListCell *lc;
1632 : :
1633 [ + - ]: 208 : Assert(argnames != NIL);
1634 [ + - ]: 208 : Assert(numposargs >= 0);
1635 [ + - ]: 208 : Assert(nargs <= pronargs);
1636 : :
1637 : : /* Ignore this function if its proargnames is null */
1638 : 208 : (void) SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_proargnames,
1639 : : &isnull);
1640 [ - + ]: 208 : if (isnull)
1641 : 0 : return false;
1642 : :
1643 : : /* OK, let's extract the argument names and types */
1644 : 208 : pronallargs = get_func_arg_info(proctup,
1645 : : &p_argtypes, &p_argnames, &p_argmodes);
1646 [ + - ]: 208 : Assert(p_argnames != NULL);
1647 : :
1648 [ + + + - ]: 208 : Assert(include_out_arguments ? (pronargs == pronallargs) : (pronargs <= pronallargs));
1649 : :
1650 : : /* initialize state for matching */
1651 : 208 : *argnumbers = (int *) palloc(pronargs * sizeof(int));
1652 : 208 : memset(arggiven, false, pronargs * sizeof(bool));
1653 : :
1654 : : /* there are numposargs positional args before the named args */
1655 [ + + ]: 436 : for (ap = 0; ap < numposargs; ap++)
1656 : : {
1657 : 228 : (*argnumbers)[ap] = ap;
1658 : 228 : arggiven[ap] = true;
1659 : 228 : }
1660 : :
1661 : : /* now examine the named args */
1662 [ + - + + : 553 : foreach(lc, argnames)
+ + + + ]
1663 : : {
1664 : 345 : char *argname = (char *) lfirst(lc);
1665 : 345 : bool found;
1666 : 345 : int i;
1667 : :
1668 : 345 : pp = 0;
1669 : 345 : found = false;
1670 [ + + ]: 1020 : for (i = 0; i < pronallargs; i++)
1671 : : {
1672 : : /* consider only input params, except with include_out_arguments */
1673 [ + + ]: 1018 : if (!include_out_arguments &&
1674 [ + + + + ]: 1007 : p_argmodes &&
1675 [ + + ]: 87 : (p_argmodes[i] != FUNC_PARAM_IN &&
1676 [ + - ]: 14 : p_argmodes[i] != FUNC_PARAM_INOUT &&
1677 : 14 : p_argmodes[i] != FUNC_PARAM_VARIADIC))
1678 : 8 : continue;
1679 [ + - + + ]: 1010 : if (p_argnames[i] && strcmp(p_argnames[i], argname) == 0)
1680 : : {
1681 : : /* note if argname matches a positional argument */
1682 [ + + ]: 343 : if (arggiven[pp])
1683 : 2 : arg_filled_twice = true;
1684 : 343 : arggiven[pp] = true;
1685 : 343 : (*argnumbers)[ap] = pp;
1686 : 343 : found = true;
1687 : 343 : break;
1688 : : }
1689 : : /* increase pp only for considered parameters */
1690 : 667 : pp++;
1691 : 667 : }
1692 : : /* if name isn't in proargnames, fail */
1693 [ + + ]: 345 : if (!found)
1694 : 2 : return false;
1695 : 343 : ap++;
1696 [ + + ]: 345 : }
1697 : :
1698 [ + - ]: 206 : Assert(ap == nargs); /* processed all actual parameters */
1699 : :
1700 : : /* If we get here, the function did match all the supplied argnames */
1701 : 206 : *fgc_flags |= FGC_ARGNAMES_MATCH;
1702 : :
1703 : : /* ... however, some of them might have been placed wrong */
1704 [ + + ]: 206 : if (arg_filled_twice)
1705 : 2 : return false; /* some argname matched a positional argument */
1706 : :
1707 : : /* If we get here, the call doesn't have invalid mixed notation */
1708 : 204 : *fgc_flags |= FGC_ARGNAMES_NONDUP;
1709 : :
1710 : : /* Check for default arguments */
1711 [ + + ]: 204 : if (nargs < pronargs)
1712 : : {
1713 : 143 : int first_arg_with_default = pronargs - procform->pronargdefaults;
1714 : :
1715 [ + + ]: 564 : for (pp = numposargs; pp < pronargs; pp++)
1716 : : {
1717 [ + + ]: 422 : if (arggiven[pp])
1718 : 176 : continue;
1719 : : /* fail if arg not given and no default available */
1720 [ + + ]: 246 : if (pp < first_arg_with_default)
1721 : 1 : return false;
1722 : 245 : (*argnumbers)[ap++] = pp;
1723 : 245 : }
1724 [ + + ]: 143 : }
1725 : :
1726 [ + - ]: 203 : Assert(ap == pronargs); /* processed all function parameters */
1727 : :
1728 : : /* If we get here, the call supplies all the required arguments */
1729 : 203 : *fgc_flags |= FGC_ARGNAMES_ALL;
1730 : :
1731 : 203 : return true;
1732 : 208 : }
1733 : :
1734 : : /*
1735 : : * FunctionIsVisible
1736 : : * Determine whether a function (identified by OID) is visible in the
1737 : : * current search path. Visible means "would be found by searching
1738 : : * for the unqualified function name with exact argument matches".
1739 : : */
1740 : : bool
1741 : 1506 : FunctionIsVisible(Oid funcid)
1742 : : {
1743 : 1506 : return FunctionIsVisibleExt(funcid, NULL);
1744 : : }
1745 : :
1746 : : /*
1747 : : * FunctionIsVisibleExt
1748 : : * As above, but if the function isn't found and is_missing is not NULL,
1749 : : * then set *is_missing = true and return false instead of throwing
1750 : : * an error. (Caller must initialize *is_missing = false.)
1751 : : */
1752 : : static bool
1753 : 1629 : FunctionIsVisibleExt(Oid funcid, bool *is_missing)
1754 : : {
1755 : 1629 : HeapTuple proctup;
1756 : 1629 : Form_pg_proc procform;
1757 : 1629 : Oid pronamespace;
1758 : 1629 : bool visible;
1759 : :
1760 : 1629 : proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
1761 [ + - ]: 1629 : if (!HeapTupleIsValid(proctup))
1762 : : {
1763 [ # # ]: 0 : if (is_missing != NULL)
1764 : : {
1765 : 0 : *is_missing = true;
1766 : 0 : return false;
1767 : : }
1768 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for function %u", funcid);
1769 : 0 : }
1770 : 1629 : procform = (Form_pg_proc) GETSTRUCT(proctup);
1771 : :
1772 : 1629 : recomputeNamespacePath();
1773 : :
1774 : : /*
1775 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
1776 : : * the system namespace are surely in the path and so we needn't even do
1777 : : * list_member_oid() for them.
1778 : : */
1779 : 1629 : pronamespace = procform->pronamespace;
1780 [ + + + + ]: 1629 : if (pronamespace != PG_CATALOG_NAMESPACE &&
1781 : 1140 : !list_member_oid(activeSearchPath, pronamespace))
1782 : 26 : visible = false;
1783 : : else
1784 : : {
1785 : : /*
1786 : : * If it is in the path, it might still not be visible; it could be
1787 : : * hidden by another proc of the same name and arguments earlier in
1788 : : * the path. So we must do a slow check to see if this is the same
1789 : : * proc that would be found by FuncnameGetCandidates.
1790 : : */
1791 : 1603 : char *proname = NameStr(procform->proname);
1792 : 1603 : int nargs = procform->pronargs;
1793 : 1603 : FuncCandidateList clist;
1794 : 1603 : int fgc_flags;
1795 : :
1796 : 1603 : visible = false;
1797 : :
1798 : 3206 : clist = FuncnameGetCandidates(list_make1(makeString(proname)),
1799 : 1603 : nargs, NIL, false, false, false, false,
1800 : : &fgc_flags);
1801 : :
1802 [ + + ]: 1784 : for (; clist; clist = clist->next)
1803 : : {
1804 : 3566 : if (memcmp(clist->args, procform->proargtypes.values,
1805 [ + + + + ]: 3566 : nargs * sizeof(Oid)) == 0)
1806 : : {
1807 : : /* Found the expected entry; is it the right proc? */
1808 : 1602 : visible = (clist->oid == funcid);
1809 : 1602 : break;
1810 : : }
1811 : 181 : }
1812 : 1603 : }
1813 : :
1814 : 1629 : ReleaseSysCache(proctup);
1815 : :
1816 : 1629 : return visible;
1817 : 1629 : }
1818 : :
1819 : :
1820 : : /*
1821 : : * OpernameGetOprid
1822 : : * Given a possibly-qualified operator name and exact input datatypes,
1823 : : * look up the operator. Returns InvalidOid if not found.
1824 : : *
1825 : : * Pass oprleft = InvalidOid for a prefix op.
1826 : : *
1827 : : * If the operator name is not schema-qualified, it is sought in the current
1828 : : * namespace search path. If the name is schema-qualified and the given
1829 : : * schema does not exist, InvalidOid is returned.
1830 : : */
1831 : : Oid
1832 : 6764 : OpernameGetOprid(List *names, Oid oprleft, Oid oprright)
1833 : : {
1834 : 6764 : char *schemaname;
1835 : 6764 : char *opername;
1836 : 6764 : CatCList *catlist;
1837 : 6764 : ListCell *l;
1838 : :
1839 : : /* deconstruct the name list */
1840 : 6764 : DeconstructQualifiedName(names, &schemaname, &opername);
1841 : :
1842 [ + + ]: 6764 : if (schemaname)
1843 : : {
1844 : : /* search only in exact schema given */
1845 : 235 : Oid namespaceId;
1846 : :
1847 : 235 : namespaceId = LookupExplicitNamespace(schemaname, true);
1848 [ + + ]: 235 : if (OidIsValid(namespaceId))
1849 : : {
1850 : 231 : HeapTuple opertup;
1851 : :
1852 : 231 : opertup = SearchSysCache4(OPERNAMENSP,
1853 : 231 : CStringGetDatum(opername),
1854 : 231 : ObjectIdGetDatum(oprleft),
1855 : 231 : ObjectIdGetDatum(oprright),
1856 : 231 : ObjectIdGetDatum(namespaceId));
1857 [ + + ]: 231 : if (HeapTupleIsValid(opertup))
1858 : : {
1859 : 113 : Form_pg_operator operclass = (Form_pg_operator) GETSTRUCT(opertup);
1860 : 113 : Oid result = operclass->oid;
1861 : :
1862 : 113 : ReleaseSysCache(opertup);
1863 : 113 : return result;
1864 : 113 : }
1865 [ + + ]: 231 : }
1866 : :
1867 : 122 : return InvalidOid;
1868 : 235 : }
1869 : :
1870 : : /* Search syscache by name and argument types */
1871 : 6529 : catlist = SearchSysCacheList3(OPERNAMENSP,
1872 : : CStringGetDatum(opername),
1873 : : ObjectIdGetDatum(oprleft),
1874 : : ObjectIdGetDatum(oprright));
1875 : :
1876 [ + + ]: 6529 : if (catlist->n_members == 0)
1877 : : {
1878 : : /* no hope, fall out early */
1879 : 1483 : ReleaseSysCacheList(catlist);
1880 : 1483 : return InvalidOid;
1881 : : }
1882 : :
1883 : : /*
1884 : : * We have to find the list member that is first in the search path, if
1885 : : * there's more than one. This doubly-nested loop looks ugly, but in
1886 : : * practice there should usually be few catlist members.
1887 : : */
1888 : 5046 : recomputeNamespacePath();
1889 : :
1890 [ + - - + : 11489 : foreach(l, activeSearchPath)
- + + - ]
1891 : : {
1892 : 6443 : Oid namespaceId = lfirst_oid(l);
1893 : 6443 : int i;
1894 : :
1895 [ + + ]: 6443 : if (namespaceId == myTempNamespace)
1896 : 1289 : continue; /* do not look in temp namespace */
1897 : :
1898 [ + + ]: 5268 : for (i = 0; i < catlist->n_members; i++)
1899 : : {
1900 : 5160 : HeapTuple opertup = &catlist->members[i]->tuple;
1901 : 5160 : Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
1902 : :
1903 [ + + ]: 5160 : if (operform->oprnamespace == namespaceId)
1904 : : {
1905 : 5046 : Oid result = operform->oid;
1906 : :
1907 : 5046 : ReleaseSysCacheList(catlist);
1908 : 5046 : return result;
1909 : 5046 : }
1910 [ + + ]: 5160 : }
1911 [ + + + ]: 6443 : }
1912 : :
1913 : 0 : ReleaseSysCacheList(catlist);
1914 : 0 : return InvalidOid;
1915 : 6764 : }
1916 : :
1917 : : /*
1918 : : * OpernameGetCandidates
1919 : : * Given a possibly-qualified operator name and operator kind,
1920 : : * retrieve a list of the possible matches.
1921 : : *
1922 : : * If oprkind is '\0', we return all operators matching the given name,
1923 : : * regardless of arguments.
1924 : : *
1925 : : * We search a single namespace if the operator name is qualified, else
1926 : : * all namespaces in the search path. The return list will never contain
1927 : : * multiple entries with identical argument lists --- in the multiple-
1928 : : * namespace case, we arrange for entries in earlier namespaces to mask
1929 : : * identical entries in later namespaces.
1930 : : *
1931 : : * The returned items always have two args[] entries --- the first will be
1932 : : * InvalidOid for a prefix oprkind. nargs is always 2, too.
1933 : : *
1934 : : * We return an empty list (NULL) if no suitable matches can be found. If the
1935 : : * operator name was schema-qualified with a schema that does not exist, then
1936 : : * we return an empty list if missing_schema_ok is true and otherwise throw an
1937 : : * error. (missing_schema_ok does not affect the behavior otherwise.)
1938 : : *
1939 : : * The output argument *fgc_flags is filled with a bitmask indicating how
1940 : : * far we were able to match the supplied information. This is not of much
1941 : : * interest if any candidates were found, but if not, it can help callers
1942 : : * produce an on-point error message.
1943 : : */
1944 : : FuncCandidateList
1945 : 1561 : OpernameGetCandidates(List *names, char oprkind, bool missing_schema_ok,
1946 : : int *fgc_flags)
1947 : : {
1948 : 1561 : FuncCandidateList resultList = NULL;
1949 : 1561 : char *resultSpace = NULL;
1950 : 1561 : int nextResult = 0;
1951 : 1561 : char *schemaname;
1952 : 1561 : char *opername;
1953 : 1561 : Oid namespaceId;
1954 : 1561 : CatCList *catlist;
1955 : 1561 : int i;
1956 : :
1957 : : /* initialize output fgc_flags to empty */
1958 : 1561 : *fgc_flags = 0;
1959 : :
1960 : : /* deconstruct the name list */
1961 : 1561 : DeconstructQualifiedName(names, &schemaname, &opername);
1962 : :
1963 [ + + ]: 1561 : if (schemaname)
1964 : : {
1965 : : /* use exact schema given */
1966 : 123 : *fgc_flags |= FGC_SCHEMA_GIVEN; /* report that a schema is given */
1967 : 123 : namespaceId = LookupExplicitNamespace(schemaname, missing_schema_ok);
1968 [ + + ]: 123 : if (!OidIsValid(namespaceId))
1969 : 3 : return NULL;
1970 : 120 : *fgc_flags |= FGC_SCHEMA_EXISTS; /* report that the schema exists */
1971 : 120 : }
1972 : : else
1973 : : {
1974 : : /* flag to indicate we need namespace search */
1975 : 1438 : namespaceId = InvalidOid;
1976 : 1438 : recomputeNamespacePath();
1977 : : }
1978 : :
1979 : : /* Search syscache by name only */
1980 : 1558 : catlist = SearchSysCacheList1(OPERNAMENSP, CStringGetDatum(opername));
1981 : :
1982 : : /*
1983 : : * In typical scenarios, most if not all of the operators found by the
1984 : : * catcache search will end up getting returned; and there can be quite a
1985 : : * few, for common operator names such as '=' or '+'. To reduce the time
1986 : : * spent in palloc, we allocate the result space as an array large enough
1987 : : * to hold all the operators. The original coding of this routine did a
1988 : : * separate palloc for each operator, but profiling revealed that the
1989 : : * pallocs used an unreasonably large fraction of parsing time.
1990 : : */
1991 : : #define SPACE_PER_OP MAXALIGN(offsetof(struct _FuncCandidateList, args) + \
1992 : : 2 * sizeof(Oid))
1993 : :
1994 [ + + ]: 1558 : if (catlist->n_members > 0)
1995 : 1555 : resultSpace = palloc(catlist->n_members * SPACE_PER_OP);
1996 : :
1997 [ + + ]: 61169 : for (i = 0; i < catlist->n_members; i++)
1998 : : {
1999 : 59611 : HeapTuple opertup = &catlist->members[i]->tuple;
2000 : 59611 : Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
2001 : 59611 : int pathpos = 0;
2002 : 59611 : FuncCandidateList newResult;
2003 : :
2004 : : /* Ignore operators of wrong kind, if specific kind requested */
2005 [ + + + + ]: 59611 : if (oprkind && operform->oprkind != oprkind)
2006 : 1352 : continue;
2007 : :
2008 : 58259 : *fgc_flags |= FGC_NAME_EXISTS; /* the name is present in pg_operator */
2009 : :
2010 [ + + ]: 58259 : if (OidIsValid(namespaceId))
2011 : : {
2012 : : /* Consider only opers in specified namespace */
2013 [ - + ]: 552 : if (operform->oprnamespace != namespaceId)
2014 : 0 : continue;
2015 : : /* No need to check args, they must all be different */
2016 : 552 : }
2017 : : else
2018 : : {
2019 : : /*
2020 : : * Consider only opers that are in the search path and are not in
2021 : : * the temp namespace.
2022 : : */
2023 : 57707 : ListCell *nsp;
2024 : :
2025 [ + - + + : 131014 : foreach(nsp, activeSearchPath)
+ + ]
2026 : : {
2027 [ + + + - ]: 73307 : if (operform->oprnamespace == lfirst_oid(nsp) &&
2028 : 57686 : operform->oprnamespace != myTempNamespace)
2029 : 57686 : break;
2030 : 15621 : pathpos++;
2031 : 15621 : }
2032 [ + + ]: 57707 : if (nsp == NULL)
2033 : 21 : continue; /* oper is not in search path */
2034 : :
2035 : : /*
2036 : : * Okay, it's in the search path, but does it have the same
2037 : : * arguments as something we already accepted? If so, keep only
2038 : : * the one that appears earlier in the search path.
2039 : : *
2040 : : * If we have an ordered list from SearchSysCacheList (the normal
2041 : : * case), then any conflicting oper must immediately adjoin this
2042 : : * one in the list, so we only need to look at the newest result
2043 : : * item. If we have an unordered list, we have to scan the whole
2044 : : * result list.
2045 : : */
2046 [ + + ]: 57686 : if (resultList)
2047 : : {
2048 : 56252 : FuncCandidateList prevResult;
2049 : :
2050 [ + - ]: 56252 : if (catlist->ordered)
2051 : : {
2052 [ + + + - ]: 56252 : if (operform->oprleft == resultList->args[0] &&
2053 : 16798 : operform->oprright == resultList->args[1])
2054 : 0 : prevResult = resultList;
2055 : : else
2056 : 56252 : prevResult = NULL;
2057 : 56252 : }
2058 : : else
2059 : : {
2060 [ # # ]: 0 : for (prevResult = resultList;
2061 : 0 : prevResult;
2062 : 0 : prevResult = prevResult->next)
2063 : : {
2064 [ # # # # ]: 0 : if (operform->oprleft == prevResult->args[0] &&
2065 : 0 : operform->oprright == prevResult->args[1])
2066 : 0 : break;
2067 : 0 : }
2068 : : }
2069 [ - + ]: 56252 : if (prevResult)
2070 : : {
2071 : : /* We have a match with a previous result */
2072 [ # # ]: 0 : Assert(pathpos != prevResult->pathpos);
2073 [ # # ]: 0 : if (pathpos > prevResult->pathpos)
2074 : 0 : continue; /* keep previous result */
2075 : : /* replace previous result */
2076 : 0 : prevResult->pathpos = pathpos;
2077 : 0 : prevResult->oid = operform->oid;
2078 : 0 : continue; /* args are same, of course */
2079 : : }
2080 [ - + ]: 56252 : }
2081 [ + + ]: 57707 : }
2082 : :
2083 : 58238 : *fgc_flags |= FGC_NAME_VISIBLE; /* operator is in the right schema */
2084 : :
2085 : : /*
2086 : : * Okay to add it to result list
2087 : : */
2088 : 58238 : newResult = (FuncCandidateList) (resultSpace + nextResult);
2089 : 58238 : nextResult += SPACE_PER_OP;
2090 : :
2091 : 58238 : newResult->pathpos = pathpos;
2092 : 58238 : newResult->oid = operform->oid;
2093 : 58238 : newResult->nominalnargs = 2;
2094 : 58238 : newResult->nargs = 2;
2095 : 58238 : newResult->nvargs = 0;
2096 : 58238 : newResult->ndargs = 0;
2097 : 58238 : newResult->argnumbers = NULL;
2098 : 58238 : newResult->args[0] = operform->oprleft;
2099 : 58238 : newResult->args[1] = operform->oprright;
2100 : 58238 : newResult->next = resultList;
2101 : 58238 : resultList = newResult;
2102 [ - + + ]: 59611 : }
2103 : :
2104 : 1558 : ReleaseSysCacheList(catlist);
2105 : :
2106 : 1558 : return resultList;
2107 : 1561 : }
2108 : :
2109 : : /*
2110 : : * OperatorIsVisible
2111 : : * Determine whether an operator (identified by OID) is visible in the
2112 : : * current search path. Visible means "would be found by searching
2113 : : * for the unqualified operator name with exact argument matches".
2114 : : */
2115 : : bool
2116 : 91 : OperatorIsVisible(Oid oprid)
2117 : : {
2118 : 91 : return OperatorIsVisibleExt(oprid, NULL);
2119 : : }
2120 : :
2121 : : /*
2122 : : * OperatorIsVisibleExt
2123 : : * As above, but if the operator isn't found and is_missing is not NULL,
2124 : : * then set *is_missing = true and return false instead of throwing
2125 : : * an error. (Caller must initialize *is_missing = false.)
2126 : : */
2127 : : static bool
2128 : 108 : OperatorIsVisibleExt(Oid oprid, bool *is_missing)
2129 : : {
2130 : 108 : HeapTuple oprtup;
2131 : 108 : Form_pg_operator oprform;
2132 : 108 : Oid oprnamespace;
2133 : 108 : bool visible;
2134 : :
2135 : 108 : oprtup = SearchSysCache1(OPEROID, ObjectIdGetDatum(oprid));
2136 [ + - ]: 108 : if (!HeapTupleIsValid(oprtup))
2137 : : {
2138 [ # # ]: 0 : if (is_missing != NULL)
2139 : : {
2140 : 0 : *is_missing = true;
2141 : 0 : return false;
2142 : : }
2143 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for operator %u", oprid);
2144 : 0 : }
2145 : 108 : oprform = (Form_pg_operator) GETSTRUCT(oprtup);
2146 : :
2147 : 108 : recomputeNamespacePath();
2148 : :
2149 : : /*
2150 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2151 : : * the system namespace are surely in the path and so we needn't even do
2152 : : * list_member_oid() for them.
2153 : : */
2154 : 108 : oprnamespace = oprform->oprnamespace;
2155 [ + + + + ]: 108 : if (oprnamespace != PG_CATALOG_NAMESPACE &&
2156 : 11 : !list_member_oid(activeSearchPath, oprnamespace))
2157 : 3 : visible = false;
2158 : : else
2159 : : {
2160 : : /*
2161 : : * If it is in the path, it might still not be visible; it could be
2162 : : * hidden by another operator of the same name and arguments earlier
2163 : : * in the path. So we must do a slow check to see if this is the same
2164 : : * operator that would be found by OpernameGetOprid.
2165 : : */
2166 : 105 : char *oprname = NameStr(oprform->oprname);
2167 : :
2168 : 315 : visible = (OpernameGetOprid(list_make1(makeString(oprname)),
2169 : 105 : oprform->oprleft, oprform->oprright)
2170 : 105 : == oprid);
2171 : 105 : }
2172 : :
2173 : 108 : ReleaseSysCache(oprtup);
2174 : :
2175 : 108 : return visible;
2176 : 108 : }
2177 : :
2178 : :
2179 : : /*
2180 : : * OpclassnameGetOpcid
2181 : : * Try to resolve an unqualified index opclass name.
2182 : : * Returns OID if opclass found in search path, else InvalidOid.
2183 : : *
2184 : : * This is essentially the same as TypenameGetTypid, but we have to have
2185 : : * an extra argument for the index AM OID.
2186 : : */
2187 : : Oid
2188 : 436 : OpclassnameGetOpcid(Oid amid, const char *opcname)
2189 : : {
2190 : 436 : Oid opcid;
2191 : 436 : ListCell *l;
2192 : :
2193 : 436 : recomputeNamespacePath();
2194 : :
2195 [ + - + + : 972 : foreach(l, activeSearchPath)
+ + + + ]
2196 : : {
2197 : 536 : Oid namespaceId = lfirst_oid(l);
2198 : :
2199 [ + + ]: 536 : if (namespaceId == myTempNamespace)
2200 : 47 : continue; /* do not look in temp namespace */
2201 : :
2202 : 489 : opcid = GetSysCacheOid3(CLAAMNAMENSP, Anum_pg_opclass_oid,
2203 : : ObjectIdGetDatum(amid),
2204 : : PointerGetDatum(opcname),
2205 : : ObjectIdGetDatum(namespaceId));
2206 [ + + ]: 489 : if (OidIsValid(opcid))
2207 : 432 : return opcid;
2208 [ + + + ]: 536 : }
2209 : :
2210 : : /* Not found in path */
2211 : 4 : return InvalidOid;
2212 : 436 : }
2213 : :
2214 : : /*
2215 : : * OpclassIsVisible
2216 : : * Determine whether an opclass (identified by OID) is visible in the
2217 : : * current search path. Visible means "would be found by searching
2218 : : * for the unqualified opclass name".
2219 : : */
2220 : : bool
2221 : 23 : OpclassIsVisible(Oid opcid)
2222 : : {
2223 : 23 : return OpclassIsVisibleExt(opcid, NULL);
2224 : : }
2225 : :
2226 : : /*
2227 : : * OpclassIsVisibleExt
2228 : : * As above, but if the opclass isn't found and is_missing is not NULL,
2229 : : * then set *is_missing = true and return false instead of throwing
2230 : : * an error. (Caller must initialize *is_missing = false.)
2231 : : */
2232 : : static bool
2233 : 26 : OpclassIsVisibleExt(Oid opcid, bool *is_missing)
2234 : : {
2235 : 26 : HeapTuple opctup;
2236 : 26 : Form_pg_opclass opcform;
2237 : 26 : Oid opcnamespace;
2238 : 26 : bool visible;
2239 : :
2240 : 26 : opctup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opcid));
2241 [ + - ]: 26 : if (!HeapTupleIsValid(opctup))
2242 : : {
2243 [ # # ]: 0 : if (is_missing != NULL)
2244 : : {
2245 : 0 : *is_missing = true;
2246 : 0 : return false;
2247 : : }
2248 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for opclass %u", opcid);
2249 : 0 : }
2250 : 26 : opcform = (Form_pg_opclass) GETSTRUCT(opctup);
2251 : :
2252 : 26 : recomputeNamespacePath();
2253 : :
2254 : : /*
2255 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2256 : : * the system namespace are surely in the path and so we needn't even do
2257 : : * list_member_oid() for them.
2258 : : */
2259 : 26 : opcnamespace = opcform->opcnamespace;
2260 [ + + + + ]: 26 : if (opcnamespace != PG_CATALOG_NAMESPACE &&
2261 : 9 : !list_member_oid(activeSearchPath, opcnamespace))
2262 : 2 : visible = false;
2263 : : else
2264 : : {
2265 : : /*
2266 : : * If it is in the path, it might still not be visible; it could be
2267 : : * hidden by another opclass of the same name earlier in the path. So
2268 : : * we must do a slow check to see if this opclass would be found by
2269 : : * OpclassnameGetOpcid.
2270 : : */
2271 : 24 : char *opcname = NameStr(opcform->opcname);
2272 : :
2273 : 24 : visible = (OpclassnameGetOpcid(opcform->opcmethod, opcname) == opcid);
2274 : 24 : }
2275 : :
2276 : 26 : ReleaseSysCache(opctup);
2277 : :
2278 : 26 : return visible;
2279 : 26 : }
2280 : :
2281 : : /*
2282 : : * OpfamilynameGetOpfid
2283 : : * Try to resolve an unqualified index opfamily name.
2284 : : * Returns OID if opfamily found in search path, else InvalidOid.
2285 : : *
2286 : : * This is essentially the same as TypenameGetTypid, but we have to have
2287 : : * an extra argument for the index AM OID.
2288 : : */
2289 : : Oid
2290 : 215 : OpfamilynameGetOpfid(Oid amid, const char *opfname)
2291 : : {
2292 : 215 : Oid opfid;
2293 : 215 : ListCell *l;
2294 : :
2295 : 215 : recomputeNamespacePath();
2296 : :
2297 [ + - + + : 640 : foreach(l, activeSearchPath)
+ + + + ]
2298 : : {
2299 : 425 : Oid namespaceId = lfirst_oid(l);
2300 : :
2301 [ + + ]: 425 : if (namespaceId == myTempNamespace)
2302 : 70 : continue; /* do not look in temp namespace */
2303 : :
2304 : 355 : opfid = GetSysCacheOid3(OPFAMILYAMNAMENSP, Anum_pg_opfamily_oid,
2305 : : ObjectIdGetDatum(amid),
2306 : : PointerGetDatum(opfname),
2307 : : ObjectIdGetDatum(namespaceId));
2308 [ + + ]: 355 : if (OidIsValid(opfid))
2309 : 213 : return opfid;
2310 [ + + + ]: 425 : }
2311 : :
2312 : : /* Not found in path */
2313 : 2 : return InvalidOid;
2314 : 215 : }
2315 : :
2316 : : /*
2317 : : * OpfamilyIsVisible
2318 : : * Determine whether an opfamily (identified by OID) is visible in the
2319 : : * current search path. Visible means "would be found by searching
2320 : : * for the unqualified opfamily name".
2321 : : */
2322 : : bool
2323 : 81 : OpfamilyIsVisible(Oid opfid)
2324 : : {
2325 : 81 : return OpfamilyIsVisibleExt(opfid, NULL);
2326 : : }
2327 : :
2328 : : /*
2329 : : * OpfamilyIsVisibleExt
2330 : : * As above, but if the opfamily isn't found and is_missing is not NULL,
2331 : : * then set *is_missing = true and return false instead of throwing
2332 : : * an error. (Caller must initialize *is_missing = false.)
2333 : : */
2334 : : static bool
2335 : 134 : OpfamilyIsVisibleExt(Oid opfid, bool *is_missing)
2336 : : {
2337 : 134 : HeapTuple opftup;
2338 : 134 : Form_pg_opfamily opfform;
2339 : 134 : Oid opfnamespace;
2340 : 134 : bool visible;
2341 : :
2342 : 134 : opftup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfid));
2343 [ + - ]: 134 : if (!HeapTupleIsValid(opftup))
2344 : : {
2345 [ # # ]: 0 : if (is_missing != NULL)
2346 : : {
2347 : 0 : *is_missing = true;
2348 : 0 : return false;
2349 : : }
2350 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for opfamily %u", opfid);
2351 : 0 : }
2352 : 134 : opfform = (Form_pg_opfamily) GETSTRUCT(opftup);
2353 : :
2354 : 134 : recomputeNamespacePath();
2355 : :
2356 : : /*
2357 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2358 : : * the system namespace are surely in the path and so we needn't even do
2359 : : * list_member_oid() for them.
2360 : : */
2361 : 134 : opfnamespace = opfform->opfnamespace;
2362 [ + + + + ]: 134 : if (opfnamespace != PG_CATALOG_NAMESPACE &&
2363 : 77 : !list_member_oid(activeSearchPath, opfnamespace))
2364 : 3 : visible = false;
2365 : : else
2366 : : {
2367 : : /*
2368 : : * If it is in the path, it might still not be visible; it could be
2369 : : * hidden by another opfamily of the same name earlier in the path. So
2370 : : * we must do a slow check to see if this opfamily would be found by
2371 : : * OpfamilynameGetOpfid.
2372 : : */
2373 : 131 : char *opfname = NameStr(opfform->opfname);
2374 : :
2375 : 131 : visible = (OpfamilynameGetOpfid(opfform->opfmethod, opfname) == opfid);
2376 : 131 : }
2377 : :
2378 : 134 : ReleaseSysCache(opftup);
2379 : :
2380 : 134 : return visible;
2381 : 134 : }
2382 : :
2383 : : /*
2384 : : * lookup_collation
2385 : : * If there's a collation of the given name/namespace, and it works
2386 : : * with the given encoding, return its OID. Else return InvalidOid.
2387 : : */
2388 : : static Oid
2389 : 2013 : lookup_collation(const char *collname, Oid collnamespace, int32 encoding)
2390 : : {
2391 : 2013 : Oid collid;
2392 : 2013 : HeapTuple colltup;
2393 : 2013 : Form_pg_collation collform;
2394 : :
2395 : : /* Check for encoding-specific entry (exact match) */
2396 : 2013 : collid = GetSysCacheOid3(COLLNAMEENCNSP, Anum_pg_collation_oid,
2397 : : PointerGetDatum(collname),
2398 : : Int32GetDatum(encoding),
2399 : : ObjectIdGetDatum(collnamespace));
2400 [ + + ]: 2013 : if (OidIsValid(collid))
2401 : 48 : return collid;
2402 : :
2403 : : /*
2404 : : * Check for any-encoding entry. This takes a bit more work: while libc
2405 : : * collations with collencoding = -1 do work with all encodings, ICU
2406 : : * collations only work with certain encodings, so we have to check that
2407 : : * aspect before deciding it's a match.
2408 : : */
2409 : 1965 : colltup = SearchSysCache3(COLLNAMEENCNSP,
2410 : 1965 : PointerGetDatum(collname),
2411 : 1965 : Int32GetDatum(-1),
2412 : 1965 : ObjectIdGetDatum(collnamespace));
2413 [ + + ]: 1965 : if (!HeapTupleIsValid(colltup))
2414 : 226 : return InvalidOid;
2415 : 1739 : collform = (Form_pg_collation) GETSTRUCT(colltup);
2416 [ + + ]: 1739 : if (collform->collprovider == COLLPROVIDER_ICU)
2417 : : {
2418 [ + - ]: 226 : if (is_encoding_supported_by_icu(encoding))
2419 : 226 : collid = collform->oid;
2420 : : else
2421 : 0 : collid = InvalidOid;
2422 : 226 : }
2423 : : else
2424 : : {
2425 : 1513 : collid = collform->oid;
2426 : : }
2427 : 1739 : ReleaseSysCache(colltup);
2428 : 1739 : return collid;
2429 : 2013 : }
2430 : :
2431 : : /*
2432 : : * CollationGetCollid
2433 : : * Try to resolve an unqualified collation name.
2434 : : * Returns OID if collation found in search path, else InvalidOid.
2435 : : *
2436 : : * Note that this will only find collations that work with the current
2437 : : * database's encoding.
2438 : : */
2439 : : Oid
2440 : 61 : CollationGetCollid(const char *collname)
2441 : : {
2442 : 61 : int32 dbencoding = GetDatabaseEncoding();
2443 : 61 : ListCell *l;
2444 : :
2445 : 61 : recomputeNamespacePath();
2446 : :
2447 [ + - - + : 156 : foreach(l, activeSearchPath)
- + + - ]
2448 : : {
2449 : 95 : Oid namespaceId = lfirst_oid(l);
2450 : 95 : Oid collid;
2451 : :
2452 [ + + ]: 95 : if (namespaceId == myTempNamespace)
2453 : 24 : continue; /* do not look in temp namespace */
2454 : :
2455 : 71 : collid = lookup_collation(collname, namespaceId, dbencoding);
2456 [ + + ]: 71 : if (OidIsValid(collid))
2457 : 61 : return collid;
2458 [ + + + ]: 95 : }
2459 : :
2460 : : /* Not found in path */
2461 : 0 : return InvalidOid;
2462 : 61 : }
2463 : :
2464 : : /*
2465 : : * CollationIsVisible
2466 : : * Determine whether a collation (identified by OID) is visible in the
2467 : : * current search path. Visible means "would be found by searching
2468 : : * for the unqualified collation name".
2469 : : *
2470 : : * Note that only collations that work with the current database's encoding
2471 : : * will be considered visible.
2472 : : */
2473 : : bool
2474 : 61 : CollationIsVisible(Oid collid)
2475 : : {
2476 : 61 : return CollationIsVisibleExt(collid, NULL);
2477 : : }
2478 : :
2479 : : /*
2480 : : * CollationIsVisibleExt
2481 : : * As above, but if the collation isn't found and is_missing is not NULL,
2482 : : * then set *is_missing = true and return false instead of throwing
2483 : : * an error. (Caller must initialize *is_missing = false.)
2484 : : */
2485 : : static bool
2486 : 61 : CollationIsVisibleExt(Oid collid, bool *is_missing)
2487 : : {
2488 : 61 : HeapTuple colltup;
2489 : 61 : Form_pg_collation collform;
2490 : 61 : Oid collnamespace;
2491 : 61 : bool visible;
2492 : :
2493 : 61 : colltup = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));
2494 [ + - ]: 61 : if (!HeapTupleIsValid(colltup))
2495 : : {
2496 [ # # ]: 0 : if (is_missing != NULL)
2497 : : {
2498 : 0 : *is_missing = true;
2499 : 0 : return false;
2500 : : }
2501 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for collation %u", collid);
2502 : 0 : }
2503 : 61 : collform = (Form_pg_collation) GETSTRUCT(colltup);
2504 : :
2505 : 61 : recomputeNamespacePath();
2506 : :
2507 : : /*
2508 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2509 : : * the system namespace are surely in the path and so we needn't even do
2510 : : * list_member_oid() for them.
2511 : : */
2512 : 61 : collnamespace = collform->collnamespace;
2513 [ + + + - ]: 61 : if (collnamespace != PG_CATALOG_NAMESPACE &&
2514 : 10 : !list_member_oid(activeSearchPath, collnamespace))
2515 : 0 : visible = false;
2516 : : else
2517 : : {
2518 : : /*
2519 : : * If it is in the path, it might still not be visible; it could be
2520 : : * hidden by another collation of the same name earlier in the path,
2521 : : * or it might not work with the current DB encoding. So we must do a
2522 : : * slow check to see if this collation would be found by
2523 : : * CollationGetCollid.
2524 : : */
2525 : 61 : char *collname = NameStr(collform->collname);
2526 : :
2527 : 61 : visible = (CollationGetCollid(collname) == collid);
2528 : 61 : }
2529 : :
2530 : 61 : ReleaseSysCache(colltup);
2531 : :
2532 : 61 : return visible;
2533 : 61 : }
2534 : :
2535 : :
2536 : : /*
2537 : : * ConversionGetConid
2538 : : * Try to resolve an unqualified conversion name.
2539 : : * Returns OID if conversion found in search path, else InvalidOid.
2540 : : *
2541 : : * This is essentially the same as RelnameGetRelid.
2542 : : */
2543 : : Oid
2544 : 3 : ConversionGetConid(const char *conname)
2545 : : {
2546 : 3 : Oid conid;
2547 : 3 : ListCell *l;
2548 : :
2549 : 3 : recomputeNamespacePath();
2550 : :
2551 [ + - - + : 9 : foreach(l, activeSearchPath)
- + + - ]
2552 : : {
2553 : 6 : Oid namespaceId = lfirst_oid(l);
2554 : :
2555 [ - + ]: 6 : if (namespaceId == myTempNamespace)
2556 : 0 : continue; /* do not look in temp namespace */
2557 : :
2558 : 6 : conid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
2559 : : PointerGetDatum(conname),
2560 : : ObjectIdGetDatum(namespaceId));
2561 [ + + ]: 6 : if (OidIsValid(conid))
2562 : 3 : return conid;
2563 [ - + + ]: 6 : }
2564 : :
2565 : : /* Not found in path */
2566 : 0 : return InvalidOid;
2567 : 3 : }
2568 : :
2569 : : /*
2570 : : * ConversionIsVisible
2571 : : * Determine whether a conversion (identified by OID) is visible in the
2572 : : * current search path. Visible means "would be found by searching
2573 : : * for the unqualified conversion name".
2574 : : */
2575 : : bool
2576 : 5 : ConversionIsVisible(Oid conid)
2577 : : {
2578 : 5 : return ConversionIsVisibleExt(conid, NULL);
2579 : : }
2580 : :
2581 : : /*
2582 : : * ConversionIsVisibleExt
2583 : : * As above, but if the conversion isn't found and is_missing is not NULL,
2584 : : * then set *is_missing = true and return false instead of throwing
2585 : : * an error. (Caller must initialize *is_missing = false.)
2586 : : */
2587 : : static bool
2588 : 5 : ConversionIsVisibleExt(Oid conid, bool *is_missing)
2589 : : {
2590 : 5 : HeapTuple contup;
2591 : 5 : Form_pg_conversion conform;
2592 : 5 : Oid connamespace;
2593 : 5 : bool visible;
2594 : :
2595 : 5 : contup = SearchSysCache1(CONVOID, ObjectIdGetDatum(conid));
2596 [ + - ]: 5 : if (!HeapTupleIsValid(contup))
2597 : : {
2598 [ # # ]: 0 : if (is_missing != NULL)
2599 : : {
2600 : 0 : *is_missing = true;
2601 : 0 : return false;
2602 : : }
2603 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for conversion %u", conid);
2604 : 0 : }
2605 : 5 : conform = (Form_pg_conversion) GETSTRUCT(contup);
2606 : :
2607 : 5 : recomputeNamespacePath();
2608 : :
2609 : : /*
2610 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2611 : : * the system namespace are surely in the path and so we needn't even do
2612 : : * list_member_oid() for them.
2613 : : */
2614 : 5 : connamespace = conform->connamespace;
2615 [ + - + + ]: 5 : if (connamespace != PG_CATALOG_NAMESPACE &&
2616 : 5 : !list_member_oid(activeSearchPath, connamespace))
2617 : 2 : visible = false;
2618 : : else
2619 : : {
2620 : : /*
2621 : : * If it is in the path, it might still not be visible; it could be
2622 : : * hidden by another conversion of the same name earlier in the path.
2623 : : * So we must do a slow check to see if this conversion would be found
2624 : : * by ConversionGetConid.
2625 : : */
2626 : 3 : char *conname = NameStr(conform->conname);
2627 : :
2628 : 3 : visible = (ConversionGetConid(conname) == conid);
2629 : 3 : }
2630 : :
2631 : 5 : ReleaseSysCache(contup);
2632 : :
2633 : 5 : return visible;
2634 : 5 : }
2635 : :
2636 : : /*
2637 : : * get_statistics_object_oid - find a statistics object by possibly qualified name
2638 : : *
2639 : : * If not found, returns InvalidOid if missing_ok, else throws error
2640 : : */
2641 : : Oid
2642 : 56 : get_statistics_object_oid(List *names, bool missing_ok)
2643 : : {
2644 : 56 : char *schemaname;
2645 : 56 : char *stats_name;
2646 : 56 : Oid namespaceId;
2647 : 56 : Oid stats_oid = InvalidOid;
2648 : 56 : ListCell *l;
2649 : :
2650 : : /* deconstruct the name list */
2651 : 56 : DeconstructQualifiedName(names, &schemaname, &stats_name);
2652 : :
2653 [ + + ]: 56 : if (schemaname)
2654 : : {
2655 : : /* use exact schema given */
2656 : 4 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
2657 [ - + # # ]: 4 : if (missing_ok && !OidIsValid(namespaceId))
2658 : 0 : stats_oid = InvalidOid;
2659 : : else
2660 : 4 : stats_oid = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
2661 : : PointerGetDatum(stats_name),
2662 : : ObjectIdGetDatum(namespaceId));
2663 : 4 : }
2664 : : else
2665 : : {
2666 : : /* search for it in search path */
2667 : 52 : recomputeNamespacePath();
2668 : :
2669 [ + - + + : 188 : foreach(l, activeSearchPath)
+ + ]
2670 : : {
2671 : 136 : namespaceId = lfirst_oid(l);
2672 : :
2673 [ + + ]: 136 : if (namespaceId == myTempNamespace)
2674 : 32 : continue; /* do not look in temp namespace */
2675 : 104 : stats_oid = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
2676 : : PointerGetDatum(stats_name),
2677 : : ObjectIdGetDatum(namespaceId));
2678 [ + + ]: 104 : if (OidIsValid(stats_oid))
2679 : 49 : break;
2680 : 55 : }
2681 : : }
2682 : :
2683 [ + + + + ]: 56 : if (!OidIsValid(stats_oid) && !missing_ok)
2684 [ + - + - ]: 2 : ereport(ERROR,
2685 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
2686 : : errmsg("statistics object \"%s\" does not exist",
2687 : : NameListToString(names))));
2688 : :
2689 : 108 : return stats_oid;
2690 : 54 : }
2691 : :
2692 : : /*
2693 : : * StatisticsObjIsVisible
2694 : : * Determine whether a statistics object (identified by OID) is visible in
2695 : : * the current search path. Visible means "would be found by searching
2696 : : * for the unqualified statistics object name".
2697 : : */
2698 : : bool
2699 : 75 : StatisticsObjIsVisible(Oid stxid)
2700 : : {
2701 : 75 : return StatisticsObjIsVisibleExt(stxid, NULL);
2702 : : }
2703 : :
2704 : : /*
2705 : : * StatisticsObjIsVisibleExt
2706 : : * As above, but if the statistics object isn't found and is_missing is
2707 : : * not NULL, then set *is_missing = true and return false instead of
2708 : : * throwing an error. (Caller must initialize *is_missing = false.)
2709 : : */
2710 : : static bool
2711 : 137 : StatisticsObjIsVisibleExt(Oid stxid, bool *is_missing)
2712 : : {
2713 : 137 : HeapTuple stxtup;
2714 : 137 : Form_pg_statistic_ext stxform;
2715 : 137 : Oid stxnamespace;
2716 : 137 : bool visible;
2717 : :
2718 : 137 : stxtup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(stxid));
2719 [ + - ]: 137 : if (!HeapTupleIsValid(stxtup))
2720 : : {
2721 [ # # ]: 0 : if (is_missing != NULL)
2722 : : {
2723 : 0 : *is_missing = true;
2724 : 0 : return false;
2725 : : }
2726 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for statistics object %u", stxid);
2727 : 0 : }
2728 : 137 : stxform = (Form_pg_statistic_ext) GETSTRUCT(stxtup);
2729 : :
2730 : 137 : recomputeNamespacePath();
2731 : :
2732 : : /*
2733 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2734 : : * the system namespace are surely in the path and so we needn't even do
2735 : : * list_member_oid() for them.
2736 : : */
2737 : 137 : stxnamespace = stxform->stxnamespace;
2738 [ + - + + ]: 137 : if (stxnamespace != PG_CATALOG_NAMESPACE &&
2739 : 137 : !list_member_oid(activeSearchPath, stxnamespace))
2740 : 25 : visible = false;
2741 : : else
2742 : : {
2743 : : /*
2744 : : * If it is in the path, it might still not be visible; it could be
2745 : : * hidden by another statistics object of the same name earlier in the
2746 : : * path. So we must do a slow check for conflicting objects.
2747 : : */
2748 : 112 : char *stxname = NameStr(stxform->stxname);
2749 : 112 : ListCell *l;
2750 : :
2751 : 112 : visible = false;
2752 [ + - + + : 445 : foreach(l, activeSearchPath)
+ + ]
2753 : : {
2754 : 333 : Oid namespaceId = lfirst_oid(l);
2755 : :
2756 [ + + ]: 333 : if (namespaceId == myTempNamespace)
2757 : 95 : continue; /* do not look in temp namespace */
2758 : :
2759 [ + + ]: 238 : if (namespaceId == stxnamespace)
2760 : : {
2761 : : /* Found it first in path */
2762 : 110 : visible = true;
2763 : 110 : break;
2764 : : }
2765 [ - + ]: 128 : if (SearchSysCacheExists2(STATEXTNAMENSP,
2766 : : PointerGetDatum(stxname),
2767 : : ObjectIdGetDatum(namespaceId)))
2768 : : {
2769 : : /* Found something else first in path */
2770 : 0 : break;
2771 : : }
2772 [ + + + ]: 333 : }
2773 : 112 : }
2774 : :
2775 : 137 : ReleaseSysCache(stxtup);
2776 : :
2777 : 137 : return visible;
2778 : 137 : }
2779 : :
2780 : : /*
2781 : : * get_ts_parser_oid - find a TS parser by possibly qualified name
2782 : : *
2783 : : * If not found, returns InvalidOid if missing_ok, else throws error
2784 : : */
2785 : : Oid
2786 : 48 : get_ts_parser_oid(List *names, bool missing_ok)
2787 : : {
2788 : 48 : char *schemaname;
2789 : 48 : char *parser_name;
2790 : 48 : Oid namespaceId;
2791 : 48 : Oid prsoid = InvalidOid;
2792 : 48 : ListCell *l;
2793 : :
2794 : : /* deconstruct the name list */
2795 : 48 : DeconstructQualifiedName(names, &schemaname, &parser_name);
2796 : :
2797 [ + + ]: 48 : if (schemaname)
2798 : : {
2799 : : /* use exact schema given */
2800 : 6 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
2801 [ + + + - ]: 6 : if (missing_ok && !OidIsValid(namespaceId))
2802 : 1 : prsoid = InvalidOid;
2803 : : else
2804 : 5 : prsoid = GetSysCacheOid2(TSPARSERNAMENSP, Anum_pg_ts_parser_oid,
2805 : : PointerGetDatum(parser_name),
2806 : : ObjectIdGetDatum(namespaceId));
2807 : 6 : }
2808 : : else
2809 : : {
2810 : : /* search for it in search path */
2811 : 42 : recomputeNamespacePath();
2812 : :
2813 [ + - + + : 93 : foreach(l, activeSearchPath)
+ + ]
2814 : : {
2815 : 51 : namespaceId = lfirst_oid(l);
2816 : :
2817 [ - + ]: 51 : if (namespaceId == myTempNamespace)
2818 : 0 : continue; /* do not look in temp namespace */
2819 : :
2820 : 51 : prsoid = GetSysCacheOid2(TSPARSERNAMENSP, Anum_pg_ts_parser_oid,
2821 : : PointerGetDatum(parser_name),
2822 : : ObjectIdGetDatum(namespaceId));
2823 [ + + ]: 51 : if (OidIsValid(prsoid))
2824 : 38 : break;
2825 : 13 : }
2826 : : }
2827 : :
2828 [ + + + + ]: 48 : if (!OidIsValid(prsoid) && !missing_ok)
2829 [ + - + - ]: 5 : ereport(ERROR,
2830 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
2831 : : errmsg("text search parser \"%s\" does not exist",
2832 : : NameListToString(names))));
2833 : :
2834 : 86 : return prsoid;
2835 : 43 : }
2836 : :
2837 : : /*
2838 : : * TSParserIsVisible
2839 : : * Determine whether a parser (identified by OID) is visible in the
2840 : : * current search path. Visible means "would be found by searching
2841 : : * for the unqualified parser name".
2842 : : */
2843 : : bool
2844 : 5 : TSParserIsVisible(Oid prsId)
2845 : : {
2846 : 5 : return TSParserIsVisibleExt(prsId, NULL);
2847 : : }
2848 : :
2849 : : /*
2850 : : * TSParserIsVisibleExt
2851 : : * As above, but if the parser isn't found and is_missing is not NULL,
2852 : : * then set *is_missing = true and return false instead of throwing
2853 : : * an error. (Caller must initialize *is_missing = false.)
2854 : : */
2855 : : static bool
2856 : 5 : TSParserIsVisibleExt(Oid prsId, bool *is_missing)
2857 : : {
2858 : 5 : HeapTuple tup;
2859 : 5 : Form_pg_ts_parser form;
2860 : 5 : Oid namespace;
2861 : 5 : bool visible;
2862 : :
2863 : 5 : tup = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(prsId));
2864 [ + - ]: 5 : if (!HeapTupleIsValid(tup))
2865 : : {
2866 [ # # ]: 0 : if (is_missing != NULL)
2867 : : {
2868 : 0 : *is_missing = true;
2869 : 0 : return false;
2870 : : }
2871 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for text search parser %u", prsId);
2872 : 0 : }
2873 : 5 : form = (Form_pg_ts_parser) GETSTRUCT(tup);
2874 : :
2875 : 5 : recomputeNamespacePath();
2876 : :
2877 : : /*
2878 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
2879 : : * the system namespace are surely in the path and so we needn't even do
2880 : : * list_member_oid() for them.
2881 : : */
2882 : 5 : namespace = form->prsnamespace;
2883 [ + - + + ]: 5 : if (namespace != PG_CATALOG_NAMESPACE &&
2884 : 5 : !list_member_oid(activeSearchPath, namespace))
2885 : 2 : visible = false;
2886 : : else
2887 : : {
2888 : : /*
2889 : : * If it is in the path, it might still not be visible; it could be
2890 : : * hidden by another parser of the same name earlier in the path. So
2891 : : * we must do a slow check for conflicting parsers.
2892 : : */
2893 : 3 : char *name = NameStr(form->prsname);
2894 : 3 : ListCell *l;
2895 : :
2896 : 3 : visible = false;
2897 [ + - - + : 9 : foreach(l, activeSearchPath)
- + ]
2898 : : {
2899 : 6 : Oid namespaceId = lfirst_oid(l);
2900 : :
2901 [ - + ]: 6 : if (namespaceId == myTempNamespace)
2902 : 0 : continue; /* do not look in temp namespace */
2903 : :
2904 [ + + ]: 6 : if (namespaceId == namespace)
2905 : : {
2906 : : /* Found it first in path */
2907 : 3 : visible = true;
2908 : 3 : break;
2909 : : }
2910 [ - + ]: 3 : if (SearchSysCacheExists2(TSPARSERNAMENSP,
2911 : : PointerGetDatum(name),
2912 : : ObjectIdGetDatum(namespaceId)))
2913 : : {
2914 : : /* Found something else first in path */
2915 : 0 : break;
2916 : : }
2917 [ - + + ]: 6 : }
2918 : 3 : }
2919 : :
2920 : 5 : ReleaseSysCache(tup);
2921 : :
2922 : 5 : return visible;
2923 : 5 : }
2924 : :
2925 : : /*
2926 : : * get_ts_dict_oid - find a TS dictionary by possibly qualified name
2927 : : *
2928 : : * If not found, returns InvalidOid if missing_ok, else throws error
2929 : : */
2930 : : Oid
2931 : 240 : get_ts_dict_oid(List *names, bool missing_ok)
2932 : : {
2933 : 240 : char *schemaname;
2934 : 240 : char *dict_name;
2935 : 240 : Oid namespaceId;
2936 : 240 : Oid dictoid = InvalidOid;
2937 : 240 : ListCell *l;
2938 : :
2939 : : /* deconstruct the name list */
2940 : 240 : DeconstructQualifiedName(names, &schemaname, &dict_name);
2941 : :
2942 [ + + ]: 240 : if (schemaname)
2943 : : {
2944 : : /* use exact schema given */
2945 : 5 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
2946 [ + + + - ]: 5 : if (missing_ok && !OidIsValid(namespaceId))
2947 : 1 : dictoid = InvalidOid;
2948 : : else
2949 : 4 : dictoid = GetSysCacheOid2(TSDICTNAMENSP, Anum_pg_ts_dict_oid,
2950 : : PointerGetDatum(dict_name),
2951 : : ObjectIdGetDatum(namespaceId));
2952 : 5 : }
2953 : : else
2954 : : {
2955 : : /* search for it in search path */
2956 : 235 : recomputeNamespacePath();
2957 : :
2958 [ + - + + : 574 : foreach(l, activeSearchPath)
+ + ]
2959 : : {
2960 : 339 : namespaceId = lfirst_oid(l);
2961 : :
2962 [ - + ]: 339 : if (namespaceId == myTempNamespace)
2963 : 0 : continue; /* do not look in temp namespace */
2964 : :
2965 : 339 : dictoid = GetSysCacheOid2(TSDICTNAMENSP, Anum_pg_ts_dict_oid,
2966 : : PointerGetDatum(dict_name),
2967 : : ObjectIdGetDatum(namespaceId));
2968 [ + + ]: 339 : if (OidIsValid(dictoid))
2969 : 230 : break;
2970 : 109 : }
2971 : : }
2972 : :
2973 [ + + + + ]: 240 : if (!OidIsValid(dictoid) && !missing_ok)
2974 [ + - + - ]: 5 : ereport(ERROR,
2975 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
2976 : : errmsg("text search dictionary \"%s\" does not exist",
2977 : : NameListToString(names))));
2978 : :
2979 : 470 : return dictoid;
2980 : 235 : }
2981 : :
2982 : : /*
2983 : : * TSDictionaryIsVisible
2984 : : * Determine whether a dictionary (identified by OID) is visible in the
2985 : : * current search path. Visible means "would be found by searching
2986 : : * for the unqualified dictionary name".
2987 : : */
2988 : : bool
2989 : 40 : TSDictionaryIsVisible(Oid dictId)
2990 : : {
2991 : 40 : return TSDictionaryIsVisibleExt(dictId, NULL);
2992 : : }
2993 : :
2994 : : /*
2995 : : * TSDictionaryIsVisibleExt
2996 : : * As above, but if the dictionary isn't found and is_missing is not NULL,
2997 : : * then set *is_missing = true and return false instead of throwing
2998 : : * an error. (Caller must initialize *is_missing = false.)
2999 : : */
3000 : : static bool
3001 : 40 : TSDictionaryIsVisibleExt(Oid dictId, bool *is_missing)
3002 : : {
3003 : 40 : HeapTuple tup;
3004 : 40 : Form_pg_ts_dict form;
3005 : 40 : Oid namespace;
3006 : 40 : bool visible;
3007 : :
3008 : 40 : tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));
3009 [ + - ]: 40 : if (!HeapTupleIsValid(tup))
3010 : : {
3011 [ # # ]: 0 : if (is_missing != NULL)
3012 : : {
3013 : 0 : *is_missing = true;
3014 : 0 : return false;
3015 : : }
3016 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for text search dictionary %u",
3017 : : dictId);
3018 : 0 : }
3019 : 40 : form = (Form_pg_ts_dict) GETSTRUCT(tup);
3020 : :
3021 : 40 : recomputeNamespacePath();
3022 : :
3023 : : /*
3024 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
3025 : : * the system namespace are surely in the path and so we needn't even do
3026 : : * list_member_oid() for them.
3027 : : */
3028 : 40 : namespace = form->dictnamespace;
3029 [ + + + + ]: 40 : if (namespace != PG_CATALOG_NAMESPACE &&
3030 : 6 : !list_member_oid(activeSearchPath, namespace))
3031 : 2 : visible = false;
3032 : : else
3033 : : {
3034 : : /*
3035 : : * If it is in the path, it might still not be visible; it could be
3036 : : * hidden by another dictionary of the same name earlier in the path.
3037 : : * So we must do a slow check for conflicting dictionaries.
3038 : : */
3039 : 38 : char *name = NameStr(form->dictname);
3040 : 38 : ListCell *l;
3041 : :
3042 : 38 : visible = false;
3043 [ + - - + : 80 : foreach(l, activeSearchPath)
- + ]
3044 : : {
3045 : 42 : Oid namespaceId = lfirst_oid(l);
3046 : :
3047 [ - + ]: 42 : if (namespaceId == myTempNamespace)
3048 : 0 : continue; /* do not look in temp namespace */
3049 : :
3050 [ + + ]: 42 : if (namespaceId == namespace)
3051 : : {
3052 : : /* Found it first in path */
3053 : 38 : visible = true;
3054 : 38 : break;
3055 : : }
3056 [ - + ]: 4 : if (SearchSysCacheExists2(TSDICTNAMENSP,
3057 : : PointerGetDatum(name),
3058 : : ObjectIdGetDatum(namespaceId)))
3059 : : {
3060 : : /* Found something else first in path */
3061 : 0 : break;
3062 : : }
3063 [ - + + ]: 42 : }
3064 : 38 : }
3065 : :
3066 : 40 : ReleaseSysCache(tup);
3067 : :
3068 : 40 : return visible;
3069 : 40 : }
3070 : :
3071 : : /*
3072 : : * get_ts_template_oid - find a TS template by possibly qualified name
3073 : : *
3074 : : * If not found, returns InvalidOid if missing_ok, else throws error
3075 : : */
3076 : : Oid
3077 : 66 : get_ts_template_oid(List *names, bool missing_ok)
3078 : : {
3079 : 66 : char *schemaname;
3080 : 66 : char *template_name;
3081 : 66 : Oid namespaceId;
3082 : 66 : Oid tmploid = InvalidOid;
3083 : 66 : ListCell *l;
3084 : :
3085 : : /* deconstruct the name list */
3086 : 66 : DeconstructQualifiedName(names, &schemaname, &template_name);
3087 : :
3088 [ + + ]: 66 : if (schemaname)
3089 : : {
3090 : : /* use exact schema given */
3091 : 6 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
3092 [ + + + - ]: 6 : if (missing_ok && !OidIsValid(namespaceId))
3093 : 1 : tmploid = InvalidOid;
3094 : : else
3095 : 5 : tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP, Anum_pg_ts_template_oid,
3096 : : PointerGetDatum(template_name),
3097 : : ObjectIdGetDatum(namespaceId));
3098 : 6 : }
3099 : : else
3100 : : {
3101 : : /* search for it in search path */
3102 : 60 : recomputeNamespacePath();
3103 : :
3104 [ + - + + : 129 : foreach(l, activeSearchPath)
+ + ]
3105 : : {
3106 : 69 : namespaceId = lfirst_oid(l);
3107 : :
3108 [ - + ]: 69 : if (namespaceId == myTempNamespace)
3109 : 0 : continue; /* do not look in temp namespace */
3110 : :
3111 : 69 : tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP, Anum_pg_ts_template_oid,
3112 : : PointerGetDatum(template_name),
3113 : : ObjectIdGetDatum(namespaceId));
3114 [ + + ]: 69 : if (OidIsValid(tmploid))
3115 : 56 : break;
3116 : 13 : }
3117 : : }
3118 : :
3119 [ + + + + ]: 66 : if (!OidIsValid(tmploid) && !missing_ok)
3120 [ + - + - ]: 5 : ereport(ERROR,
3121 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
3122 : : errmsg("text search template \"%s\" does not exist",
3123 : : NameListToString(names))));
3124 : :
3125 : 122 : return tmploid;
3126 : 61 : }
3127 : :
3128 : : /*
3129 : : * TSTemplateIsVisible
3130 : : * Determine whether a template (identified by OID) is visible in the
3131 : : * current search path. Visible means "would be found by searching
3132 : : * for the unqualified template name".
3133 : : */
3134 : : bool
3135 : 5 : TSTemplateIsVisible(Oid tmplId)
3136 : : {
3137 : 5 : return TSTemplateIsVisibleExt(tmplId, NULL);
3138 : : }
3139 : :
3140 : : /*
3141 : : * TSTemplateIsVisibleExt
3142 : : * As above, but if the template isn't found and is_missing is not NULL,
3143 : : * then set *is_missing = true and return false instead of throwing
3144 : : * an error. (Caller must initialize *is_missing = false.)
3145 : : */
3146 : : static bool
3147 : 5 : TSTemplateIsVisibleExt(Oid tmplId, bool *is_missing)
3148 : : {
3149 : 5 : HeapTuple tup;
3150 : 5 : Form_pg_ts_template form;
3151 : 5 : Oid namespace;
3152 : 5 : bool visible;
3153 : :
3154 : 5 : tup = SearchSysCache1(TSTEMPLATEOID, ObjectIdGetDatum(tmplId));
3155 [ + - ]: 5 : if (!HeapTupleIsValid(tup))
3156 : : {
3157 [ # # ]: 0 : if (is_missing != NULL)
3158 : : {
3159 : 0 : *is_missing = true;
3160 : 0 : return false;
3161 : : }
3162 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for text search template %u", tmplId);
3163 : 0 : }
3164 : 5 : form = (Form_pg_ts_template) GETSTRUCT(tup);
3165 : :
3166 : 5 : recomputeNamespacePath();
3167 : :
3168 : : /*
3169 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
3170 : : * the system namespace are surely in the path and so we needn't even do
3171 : : * list_member_oid() for them.
3172 : : */
3173 : 5 : namespace = form->tmplnamespace;
3174 [ + - + + ]: 5 : if (namespace != PG_CATALOG_NAMESPACE &&
3175 : 5 : !list_member_oid(activeSearchPath, namespace))
3176 : 2 : visible = false;
3177 : : else
3178 : : {
3179 : : /*
3180 : : * If it is in the path, it might still not be visible; it could be
3181 : : * hidden by another template of the same name earlier in the path. So
3182 : : * we must do a slow check for conflicting templates.
3183 : : */
3184 : 3 : char *name = NameStr(form->tmplname);
3185 : 3 : ListCell *l;
3186 : :
3187 : 3 : visible = false;
3188 [ + - - + : 9 : foreach(l, activeSearchPath)
- + ]
3189 : : {
3190 : 6 : Oid namespaceId = lfirst_oid(l);
3191 : :
3192 [ - + ]: 6 : if (namespaceId == myTempNamespace)
3193 : 0 : continue; /* do not look in temp namespace */
3194 : :
3195 [ + + ]: 6 : if (namespaceId == namespace)
3196 : : {
3197 : : /* Found it first in path */
3198 : 3 : visible = true;
3199 : 3 : break;
3200 : : }
3201 [ - + ]: 3 : if (SearchSysCacheExists2(TSTEMPLATENAMENSP,
3202 : : PointerGetDatum(name),
3203 : : ObjectIdGetDatum(namespaceId)))
3204 : : {
3205 : : /* Found something else first in path */
3206 : 0 : break;
3207 : : }
3208 [ - + + ]: 6 : }
3209 : 3 : }
3210 : :
3211 : 5 : ReleaseSysCache(tup);
3212 : :
3213 : 5 : return visible;
3214 : 5 : }
3215 : :
3216 : : /*
3217 : : * get_ts_config_oid - find a TS config by possibly qualified name
3218 : : *
3219 : : * If not found, returns InvalidOid if missing_ok, else throws error
3220 : : */
3221 : : Oid
3222 : 1459 : get_ts_config_oid(List *names, bool missing_ok)
3223 : : {
3224 : 1459 : char *schemaname;
3225 : 1459 : char *config_name;
3226 : 1459 : Oid namespaceId;
3227 : 1459 : Oid cfgoid = InvalidOid;
3228 : 1459 : ListCell *l;
3229 : :
3230 : : /* deconstruct the name list */
3231 : 1459 : DeconstructQualifiedName(names, &schemaname, &config_name);
3232 : :
3233 [ + + ]: 1459 : if (schemaname)
3234 : : {
3235 : : /* use exact schema given */
3236 : 968 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
3237 [ + + + + ]: 968 : if (missing_ok && !OidIsValid(namespaceId))
3238 : 1 : cfgoid = InvalidOid;
3239 : : else
3240 : 967 : cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP, Anum_pg_ts_config_oid,
3241 : : PointerGetDatum(config_name),
3242 : : ObjectIdGetDatum(namespaceId));
3243 : 968 : }
3244 : : else
3245 : : {
3246 : : /* search for it in search path */
3247 : 491 : recomputeNamespacePath();
3248 : :
3249 [ + - + + : 1159 : foreach(l, activeSearchPath)
+ + ]
3250 : : {
3251 : 668 : namespaceId = lfirst_oid(l);
3252 : :
3253 [ + + ]: 668 : if (namespaceId == myTempNamespace)
3254 : 117 : continue; /* do not look in temp namespace */
3255 : :
3256 : 551 : cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP, Anum_pg_ts_config_oid,
3257 : : PointerGetDatum(config_name),
3258 : : ObjectIdGetDatum(namespaceId));
3259 [ + + ]: 551 : if (OidIsValid(cfgoid))
3260 : 482 : break;
3261 : 69 : }
3262 : : }
3263 : :
3264 [ + + + + ]: 1459 : if (!OidIsValid(cfgoid) && !missing_ok)
3265 [ + - + - ]: 5 : ereport(ERROR,
3266 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
3267 : : errmsg("text search configuration \"%s\" does not exist",
3268 : : NameListToString(names))));
3269 : :
3270 : 2908 : return cfgoid;
3271 : 1454 : }
3272 : :
3273 : : /*
3274 : : * TSConfigIsVisible
3275 : : * Determine whether a text search configuration (identified by OID)
3276 : : * is visible in the current search path. Visible means "would be found
3277 : : * by searching for the unqualified text search configuration name".
3278 : : */
3279 : : bool
3280 : 6 : TSConfigIsVisible(Oid cfgid)
3281 : : {
3282 : 6 : return TSConfigIsVisibleExt(cfgid, NULL);
3283 : : }
3284 : :
3285 : : /*
3286 : : * TSConfigIsVisibleExt
3287 : : * As above, but if the configuration isn't found and is_missing is not
3288 : : * NULL, then set *is_missing = true and return false instead of throwing
3289 : : * an error. (Caller must initialize *is_missing = false.)
3290 : : */
3291 : : static bool
3292 : 6 : TSConfigIsVisibleExt(Oid cfgid, bool *is_missing)
3293 : : {
3294 : 6 : HeapTuple tup;
3295 : 6 : Form_pg_ts_config form;
3296 : 6 : Oid namespace;
3297 : 6 : bool visible;
3298 : :
3299 : 6 : tup = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgid));
3300 [ + - ]: 6 : if (!HeapTupleIsValid(tup))
3301 : : {
3302 [ # # ]: 0 : if (is_missing != NULL)
3303 : : {
3304 : 0 : *is_missing = true;
3305 : 0 : return false;
3306 : : }
3307 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for text search configuration %u",
3308 : : cfgid);
3309 : 0 : }
3310 : 6 : form = (Form_pg_ts_config) GETSTRUCT(tup);
3311 : :
3312 : 6 : recomputeNamespacePath();
3313 : :
3314 : : /*
3315 : : * Quick check: if it ain't in the path at all, it ain't visible. Items in
3316 : : * the system namespace are surely in the path and so we needn't even do
3317 : : * list_member_oid() for them.
3318 : : */
3319 : 6 : namespace = form->cfgnamespace;
3320 [ + - + + ]: 6 : if (namespace != PG_CATALOG_NAMESPACE &&
3321 : 6 : !list_member_oid(activeSearchPath, namespace))
3322 : 2 : visible = false;
3323 : : else
3324 : : {
3325 : : /*
3326 : : * If it is in the path, it might still not be visible; it could be
3327 : : * hidden by another configuration of the same name earlier in the
3328 : : * path. So we must do a slow check for conflicting configurations.
3329 : : */
3330 : 4 : char *name = NameStr(form->cfgname);
3331 : 4 : ListCell *l;
3332 : :
3333 : 4 : visible = false;
3334 [ + - - + : 12 : foreach(l, activeSearchPath)
- + ]
3335 : : {
3336 : 8 : Oid namespaceId = lfirst_oid(l);
3337 : :
3338 [ - + ]: 8 : if (namespaceId == myTempNamespace)
3339 : 0 : continue; /* do not look in temp namespace */
3340 : :
3341 [ + + ]: 8 : if (namespaceId == namespace)
3342 : : {
3343 : : /* Found it first in path */
3344 : 4 : visible = true;
3345 : 4 : break;
3346 : : }
3347 [ - + ]: 4 : if (SearchSysCacheExists2(TSCONFIGNAMENSP,
3348 : : PointerGetDatum(name),
3349 : : ObjectIdGetDatum(namespaceId)))
3350 : : {
3351 : : /* Found something else first in path */
3352 : 0 : break;
3353 : : }
3354 [ - + + ]: 8 : }
3355 : 4 : }
3356 : :
3357 : 6 : ReleaseSysCache(tup);
3358 : :
3359 : 6 : return visible;
3360 : 6 : }
3361 : :
3362 : :
3363 : : /*
3364 : : * DeconstructQualifiedName
3365 : : * Given a possibly-qualified name expressed as a list of String nodes,
3366 : : * extract the schema name and object name.
3367 : : *
3368 : : * *nspname_p is set to NULL if there is no explicit schema name.
3369 : : */
3370 : : void
3371 : 171310 : DeconstructQualifiedName(const List *names,
3372 : : char **nspname_p,
3373 : : char **objname_p)
3374 : : {
3375 : 171310 : char *catalogname;
3376 : 171310 : char *schemaname = NULL;
3377 : 171310 : char *objname = NULL;
3378 : :
3379 [ + + + + ]: 171310 : switch (list_length(names))
3380 : : {
3381 : : case 1:
3382 : 127463 : objname = strVal(linitial(names));
3383 : 127463 : break;
3384 : : case 2:
3385 : 43829 : schemaname = strVal(linitial(names));
3386 : 43829 : objname = strVal(lsecond(names));
3387 : 43829 : break;
3388 : : case 3:
3389 : 17 : catalogname = strVal(linitial(names));
3390 : 17 : schemaname = strVal(lsecond(names));
3391 : 17 : objname = strVal(lthird(names));
3392 : :
3393 : : /*
3394 : : * We check the catalog name and then ignore it.
3395 : : */
3396 [ - + ]: 17 : if (strcmp(catalogname, get_database_name(MyDatabaseId)) != 0)
3397 [ + - + - ]: 17 : ereport(ERROR,
3398 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3399 : : errmsg("cross-database references are not implemented: %s",
3400 : : NameListToString(names))));
3401 : 0 : break;
3402 : : default:
3403 [ + - + - ]: 1 : ereport(ERROR,
3404 : : (errcode(ERRCODE_SYNTAX_ERROR),
3405 : : errmsg("improper qualified name (too many dotted names): %s",
3406 : : NameListToString(names))));
3407 : 0 : break;
3408 : : }
3409 : :
3410 : 171292 : *nspname_p = schemaname;
3411 : 171292 : *objname_p = objname;
3412 : 171292 : }
3413 : :
3414 : : /*
3415 : : * LookupNamespaceNoError
3416 : : * Look up a schema name.
3417 : : *
3418 : : * Returns the namespace OID, or InvalidOid if not found.
3419 : : *
3420 : : * Note this does NOT perform any permissions check --- callers are
3421 : : * responsible for being sure that an appropriate check is made.
3422 : : * In the majority of cases LookupExplicitNamespace is preferable.
3423 : : */
3424 : : Oid
3425 : 53 : LookupNamespaceNoError(const char *nspname)
3426 : : {
3427 : : /* check for pg_temp alias */
3428 [ + - ]: 53 : if (strcmp(nspname, "pg_temp") == 0)
3429 : : {
3430 [ # # ]: 0 : if (OidIsValid(myTempNamespace))
3431 : : {
3432 [ # # ]: 0 : InvokeNamespaceSearchHook(myTempNamespace, true);
3433 : 0 : return myTempNamespace;
3434 : : }
3435 : :
3436 : : /*
3437 : : * Since this is used only for looking up existing objects, there is
3438 : : * no point in trying to initialize the temp namespace here; and doing
3439 : : * so might create problems for some callers. Just report "not found".
3440 : : */
3441 : 0 : return InvalidOid;
3442 : : }
3443 : :
3444 : 53 : return get_namespace_oid(nspname, true);
3445 : 53 : }
3446 : :
3447 : : /*
3448 : : * LookupExplicitNamespace
3449 : : * Process an explicitly-specified schema name: look up the schema
3450 : : * and verify we have USAGE (lookup) rights in it.
3451 : : *
3452 : : * Returns the namespace OID
3453 : : */
3454 : : Oid
3455 : 64857 : LookupExplicitNamespace(const char *nspname, bool missing_ok)
3456 : : {
3457 : 64857 : Oid namespaceId;
3458 : 64857 : AclResult aclresult;
3459 : :
3460 : : /* check for pg_temp alias */
3461 [ + + ]: 64857 : if (strcmp(nspname, "pg_temp") == 0)
3462 : : {
3463 [ + - ]: 15 : if (OidIsValid(myTempNamespace))
3464 : 15 : return myTempNamespace;
3465 : :
3466 : : /*
3467 : : * Since this is used only for looking up existing objects, there is
3468 : : * no point in trying to initialize the temp namespace here; and doing
3469 : : * so might create problems for some callers --- just fall through.
3470 : : */
3471 : 0 : }
3472 : :
3473 : 64842 : namespaceId = get_namespace_oid(nspname, missing_ok);
3474 [ + + + + ]: 64842 : if (missing_ok && !OidIsValid(namespaceId))
3475 : 56 : return InvalidOid;
3476 : :
3477 : 64786 : aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(), ACL_USAGE);
3478 [ + + ]: 64786 : if (aclresult != ACLCHECK_OK)
3479 : 2 : aclcheck_error(aclresult, OBJECT_SCHEMA,
3480 : 1 : nspname);
3481 : : /* Schema search hook for this lookup */
3482 [ - + ]: 64786 : InvokeNamespaceSearchHook(namespaceId, true);
3483 : :
3484 : 64786 : return namespaceId;
3485 : 64857 : }
3486 : :
3487 : : /*
3488 : : * LookupCreationNamespace
3489 : : * Look up the schema and verify we have CREATE rights on it.
3490 : : *
3491 : : * This is just like LookupExplicitNamespace except for the different
3492 : : * permission check, and that we are willing to create pg_temp if needed.
3493 : : *
3494 : : * Note: calling this may result in a CommandCounterIncrement operation,
3495 : : * if we have to create or clean out the temp namespace.
3496 : : */
3497 : : Oid
3498 : 71 : LookupCreationNamespace(const char *nspname)
3499 : : {
3500 : 71 : Oid namespaceId;
3501 : 71 : AclResult aclresult;
3502 : :
3503 : : /* check for pg_temp alias */
3504 [ + + ]: 71 : if (strcmp(nspname, "pg_temp") == 0)
3505 : : {
3506 : : /* Initialize temp namespace */
3507 : 22 : AccessTempTableNamespace(false);
3508 : 22 : return myTempNamespace;
3509 : : }
3510 : :
3511 : 49 : namespaceId = get_namespace_oid(nspname, false);
3512 : :
3513 : 49 : aclresult = object_aclcheck(NamespaceRelationId, namespaceId, GetUserId(), ACL_CREATE);
3514 [ + - ]: 49 : if (aclresult != ACLCHECK_OK)
3515 : 0 : aclcheck_error(aclresult, OBJECT_SCHEMA,
3516 : 0 : nspname);
3517 : :
3518 : 49 : return namespaceId;
3519 : 71 : }
3520 : :
3521 : : /*
3522 : : * Common checks on switching namespaces.
3523 : : *
3524 : : * We complain if either the old or new namespaces is a temporary schema
3525 : : * (or temporary toast schema), or if either the old or new namespaces is the
3526 : : * TOAST schema.
3527 : : */
3528 : : void
3529 : 80 : CheckSetNamespace(Oid oldNspOid, Oid nspOid)
3530 : : {
3531 : : /* disallow renaming into or out of temp schemas */
3532 [ + - ]: 80 : if (isAnyTempNamespace(nspOid) || isAnyTempNamespace(oldNspOid))
3533 [ # # # # ]: 0 : ereport(ERROR,
3534 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3535 : : errmsg("cannot move objects into or out of temporary schemas")));
3536 : :
3537 : : /* same for TOAST schema */
3538 [ + - ]: 80 : if (nspOid == PG_TOAST_NAMESPACE || oldNspOid == PG_TOAST_NAMESPACE)
3539 [ # # # # ]: 0 : ereport(ERROR,
3540 : : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3541 : : errmsg("cannot move objects into or out of TOAST schema")));
3542 : 80 : }
3543 : :
3544 : : /*
3545 : : * QualifiedNameGetCreationNamespace
3546 : : * Given a possibly-qualified name for an object (in List-of-Strings
3547 : : * format), determine what namespace the object should be created in.
3548 : : * Also extract and return the object name (last component of list).
3549 : : *
3550 : : * Note: this does not apply any permissions check. Callers must check
3551 : : * for CREATE rights on the selected namespace when appropriate.
3552 : : *
3553 : : * Note: calling this may result in a CommandCounterIncrement operation,
3554 : : * if we have to create or clean out the temp namespace.
3555 : : */
3556 : : Oid
3557 : 1857 : QualifiedNameGetCreationNamespace(const List *names, char **objname_p)
3558 : : {
3559 : 1857 : char *schemaname;
3560 : 1857 : Oid namespaceId;
3561 : :
3562 : : /* deconstruct the name list */
3563 : 1857 : DeconstructQualifiedName(names, &schemaname, objname_p);
3564 : :
3565 [ + + ]: 1857 : if (schemaname)
3566 : : {
3567 : : /* check for pg_temp alias */
3568 [ + + ]: 74 : if (strcmp(schemaname, "pg_temp") == 0)
3569 : : {
3570 : : /* Initialize temp namespace */
3571 : 8 : AccessTempTableNamespace(false);
3572 : 8 : return myTempNamespace;
3573 : : }
3574 : : /* use exact schema given */
3575 : 66 : namespaceId = get_namespace_oid(schemaname, false);
3576 : : /* we do not check for USAGE rights here! */
3577 : 66 : }
3578 : : else
3579 : : {
3580 : : /* use the default creation namespace */
3581 : 1783 : recomputeNamespacePath();
3582 [ - + ]: 1783 : if (activeTempCreationPending)
3583 : : {
3584 : : /* Need to initialize temp namespace */
3585 : 0 : AccessTempTableNamespace(true);
3586 : 0 : return myTempNamespace;
3587 : : }
3588 : 1783 : namespaceId = activeCreationNamespace;
3589 [ + - ]: 1783 : if (!OidIsValid(namespaceId))
3590 [ # # # # ]: 0 : ereport(ERROR,
3591 : : (errcode(ERRCODE_UNDEFINED_SCHEMA),
3592 : : errmsg("no schema has been selected to create in")));
3593 : : }
3594 : :
3595 : 1849 : return namespaceId;
3596 : 1857 : }
3597 : :
3598 : : /*
3599 : : * get_namespace_oid - given a namespace name, look up the OID
3600 : : *
3601 : : * If missing_ok is false, throw an error if namespace name not found. If
3602 : : * true, just return InvalidOid.
3603 : : */
3604 : : Oid
3605 : 77572 : get_namespace_oid(const char *nspname, bool missing_ok)
3606 : : {
3607 : 77572 : Oid oid;
3608 : :
3609 : 77572 : oid = GetSysCacheOid1(NAMESPACENAME, Anum_pg_namespace_oid,
3610 : : CStringGetDatum(nspname));
3611 [ + + + + ]: 77572 : if (!OidIsValid(oid) && !missing_ok)
3612 [ + - + - ]: 31 : ereport(ERROR,
3613 : : (errcode(ERRCODE_UNDEFINED_SCHEMA),
3614 : : errmsg("schema \"%s\" does not exist", nspname)));
3615 : :
3616 : 155082 : return oid;
3617 : 77541 : }
3618 : :
3619 : : /*
3620 : : * makeRangeVarFromNameList
3621 : : * Utility routine to convert a qualified-name list into RangeVar form.
3622 : : */
3623 : : RangeVar *
3624 : 4100 : makeRangeVarFromNameList(const List *names)
3625 : : {
3626 : 4100 : RangeVar *rel = makeRangeVar(NULL, NULL, -1);
3627 : :
3628 [ + + + - ]: 4100 : switch (list_length(names))
3629 : : {
3630 : : case 1:
3631 : 3466 : rel->relname = strVal(linitial(names));
3632 : 3466 : break;
3633 : : case 2:
3634 : 621 : rel->schemaname = strVal(linitial(names));
3635 : 621 : rel->relname = strVal(lsecond(names));
3636 : 621 : break;
3637 : : case 3:
3638 : 13 : rel->catalogname = strVal(linitial(names));
3639 : 13 : rel->schemaname = strVal(lsecond(names));
3640 : 13 : rel->relname = strVal(lthird(names));
3641 : 13 : break;
3642 : : default:
3643 [ # # # # ]: 0 : ereport(ERROR,
3644 : : (errcode(ERRCODE_SYNTAX_ERROR),
3645 : : errmsg("improper relation name (too many dotted names): %s",
3646 : : NameListToString(names))));
3647 : 0 : break;
3648 : : }
3649 : :
3650 : 8200 : return rel;
3651 : 4100 : }
3652 : :
3653 : : /*
3654 : : * NameListToString
3655 : : * Utility routine to convert a qualified-name list into a string.
3656 : : *
3657 : : * This is used primarily to form error messages, and so we do not quote
3658 : : * the list elements, for the sake of legibility.
3659 : : *
3660 : : * In most scenarios the list elements should always be String values,
3661 : : * but we also allow A_Star for the convenience of ColumnRef processing.
3662 : : */
3663 : : char *
3664 : 287 : NameListToString(const List *names)
3665 : : {
3666 : 287 : StringInfoData string;
3667 : 287 : ListCell *l;
3668 : :
3669 : 287 : initStringInfo(&string);
3670 : :
3671 [ + - + + : 645 : foreach(l, names)
+ + ]
3672 : : {
3673 : 358 : Node *name = (Node *) lfirst(l);
3674 : :
3675 [ + + ]: 358 : if (l != list_head(names))
3676 : 71 : appendStringInfoChar(&string, '.');
3677 : :
3678 [ + - ]: 358 : if (IsA(name, String))
3679 : 358 : appendStringInfoString(&string, strVal(name));
3680 [ # # ]: 0 : else if (IsA(name, A_Star))
3681 : 0 : appendStringInfoChar(&string, '*');
3682 : : else
3683 [ # # # # ]: 0 : elog(ERROR, "unexpected node type in name list: %d",
3684 : : (int) nodeTag(name));
3685 : 358 : }
3686 : :
3687 : 574 : return string.data;
3688 : 287 : }
3689 : :
3690 : : /*
3691 : : * NameListToQuotedString
3692 : : * Utility routine to convert a qualified-name list into a string.
3693 : : *
3694 : : * Same as above except that names will be double-quoted where necessary,
3695 : : * so the string could be re-parsed (eg, by textToQualifiedNameList).
3696 : : */
3697 : : char *
3698 : 0 : NameListToQuotedString(const List *names)
3699 : : {
3700 : 0 : StringInfoData string;
3701 : 0 : ListCell *l;
3702 : :
3703 : 0 : initStringInfo(&string);
3704 : :
3705 [ # # # # : 0 : foreach(l, names)
# # ]
3706 : : {
3707 [ # # ]: 0 : if (l != list_head(names))
3708 : 0 : appendStringInfoChar(&string, '.');
3709 : 0 : appendStringInfoString(&string, quote_identifier(strVal(lfirst(l))));
3710 : 0 : }
3711 : :
3712 : 0 : return string.data;
3713 : 0 : }
3714 : :
3715 : : /*
3716 : : * isTempNamespace - is the given namespace my temporary-table namespace?
3717 : : */
3718 : : bool
3719 : 57567 : isTempNamespace(Oid namespaceId)
3720 : : {
3721 [ + + + + ]: 57567 : if (OidIsValid(myTempNamespace) && myTempNamespace == namespaceId)
3722 : 1561 : return true;
3723 : 56006 : return false;
3724 : 57567 : }
3725 : :
3726 : : /*
3727 : : * isTempToastNamespace - is the given namespace my temporary-toast-table
3728 : : * namespace?
3729 : : */
3730 : : bool
3731 : 792219 : isTempToastNamespace(Oid namespaceId)
3732 : : {
3733 [ + + + + ]: 792219 : if (OidIsValid(myTempToastNamespace) && myTempToastNamespace == namespaceId)
3734 : 584 : return true;
3735 : 791635 : return false;
3736 : 792219 : }
3737 : :
3738 : : /*
3739 : : * isTempOrTempToastNamespace - is the given namespace my temporary-table
3740 : : * namespace or my temporary-toast-table namespace?
3741 : : */
3742 : : bool
3743 : 22443 : isTempOrTempToastNamespace(Oid namespaceId)
3744 : : {
3745 [ + + + + ]: 31807 : if (OidIsValid(myTempNamespace) &&
3746 [ + + ]: 14783 : (myTempNamespace == namespaceId || myTempToastNamespace == namespaceId))
3747 : 6993 : return true;
3748 : 15450 : return false;
3749 : 22443 : }
3750 : :
3751 : : /*
3752 : : * isAnyTempNamespace - is the given namespace a temporary-table namespace
3753 : : * (either my own, or another backend's)? Temporary-toast-table namespaces
3754 : : * are included, too.
3755 : : */
3756 : : bool
3757 : 28690 : isAnyTempNamespace(Oid namespaceId)
3758 : : {
3759 : 28690 : bool result;
3760 : 28690 : char *nspname;
3761 : :
3762 : : /* True if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */
3763 : 28690 : nspname = get_namespace_name(namespaceId);
3764 [ + - ]: 28690 : if (!nspname)
3765 : 0 : return false; /* no such namespace? */
3766 [ + + ]: 28690 : result = (strncmp(nspname, "pg_temp_", 8) == 0) ||
3767 : 27026 : (strncmp(nspname, "pg_toast_temp_", 14) == 0);
3768 : 28690 : pfree(nspname);
3769 : 28690 : return result;
3770 : 28690 : }
3771 : :
3772 : : /*
3773 : : * isOtherTempNamespace - is the given namespace some other backend's
3774 : : * temporary-table namespace (including temporary-toast-table namespaces)?
3775 : : *
3776 : : * Note: for most purposes in the C code, this function is obsolete. Use
3777 : : * RELATION_IS_OTHER_TEMP() instead to detect non-local temp relations.
3778 : : */
3779 : : bool
3780 : 4006 : isOtherTempNamespace(Oid namespaceId)
3781 : : {
3782 : : /* If it's my own temp namespace, say "false" */
3783 [ - + ]: 4006 : if (isTempOrTempToastNamespace(namespaceId))
3784 : 0 : return false;
3785 : : /* Else, if it's any temp namespace, say "true" */
3786 : 4006 : return isAnyTempNamespace(namespaceId);
3787 : 4006 : }
3788 : :
3789 : : /*
3790 : : * checkTempNamespaceStatus - is the given namespace owned and actively used
3791 : : * by a backend?
3792 : : *
3793 : : * Note: this can be used while scanning relations in pg_class to detect
3794 : : * orphaned temporary tables or namespaces with a backend connected to a
3795 : : * given database. The result may be out of date quickly, so the caller
3796 : : * must be careful how to handle this information.
3797 : : */
3798 : : TempNamespaceStatus
3799 : 0 : checkTempNamespaceStatus(Oid namespaceId)
3800 : : {
3801 : 0 : PGPROC *proc;
3802 : 0 : ProcNumber procNumber;
3803 : :
3804 [ # # ]: 0 : Assert(OidIsValid(MyDatabaseId));
3805 : :
3806 : 0 : procNumber = GetTempNamespaceProcNumber(namespaceId);
3807 : :
3808 : : /* No such namespace, or its name shows it's not temp? */
3809 [ # # ]: 0 : if (procNumber == INVALID_PROC_NUMBER)
3810 : 0 : return TEMP_NAMESPACE_NOT_TEMP;
3811 : :
3812 : : /* Is the backend alive? */
3813 : 0 : proc = ProcNumberGetProc(procNumber);
3814 [ # # ]: 0 : if (proc == NULL)
3815 : 0 : return TEMP_NAMESPACE_IDLE;
3816 : :
3817 : : /* Is the backend connected to the same database we are looking at? */
3818 [ # # ]: 0 : if (proc->databaseId != MyDatabaseId)
3819 : 0 : return TEMP_NAMESPACE_IDLE;
3820 : :
3821 : : /* Does the backend own the temporary namespace? */
3822 [ # # ]: 0 : if (proc->tempNamespaceId != namespaceId)
3823 : 0 : return TEMP_NAMESPACE_IDLE;
3824 : :
3825 : : /* Yup, so namespace is busy */
3826 : 0 : return TEMP_NAMESPACE_IN_USE;
3827 : 0 : }
3828 : :
3829 : : /*
3830 : : * GetTempNamespaceProcNumber - if the given namespace is a temporary-table
3831 : : * namespace (either my own, or another backend's), return the proc number
3832 : : * that owns it. Temporary-toast-table namespaces are included, too.
3833 : : * If it isn't a temp namespace, return INVALID_PROC_NUMBER.
3834 : : */
3835 : : ProcNumber
3836 : 0 : GetTempNamespaceProcNumber(Oid namespaceId)
3837 : : {
3838 : 0 : int result;
3839 : 0 : char *nspname;
3840 : :
3841 : : /* See if the namespace name starts with "pg_temp_" or "pg_toast_temp_" */
3842 : 0 : nspname = get_namespace_name(namespaceId);
3843 [ # # ]: 0 : if (!nspname)
3844 : 0 : return INVALID_PROC_NUMBER; /* no such namespace? */
3845 [ # # ]: 0 : if (strncmp(nspname, "pg_temp_", 8) == 0)
3846 : 0 : result = atoi(nspname + 8);
3847 [ # # ]: 0 : else if (strncmp(nspname, "pg_toast_temp_", 14) == 0)
3848 : 0 : result = atoi(nspname + 14);
3849 : : else
3850 : 0 : result = INVALID_PROC_NUMBER;
3851 : 0 : pfree(nspname);
3852 : 0 : return result;
3853 : 0 : }
3854 : :
3855 : : /*
3856 : : * GetTempToastNamespace - get the OID of my temporary-toast-table namespace,
3857 : : * which must already be assigned. (This is only used when creating a toast
3858 : : * table for a temp table, so we must have already done InitTempTableNamespace)
3859 : : */
3860 : : Oid
3861 : 145 : GetTempToastNamespace(void)
3862 : : {
3863 [ + - ]: 145 : Assert(OidIsValid(myTempToastNamespace));
3864 : 145 : return myTempToastNamespace;
3865 : : }
3866 : :
3867 : :
3868 : : /*
3869 : : * GetTempNamespaceState - fetch status of session's temporary namespace
3870 : : *
3871 : : * This is used for conveying state to a parallel worker, and is not meant
3872 : : * for general-purpose access.
3873 : : */
3874 : : void
3875 : 155 : GetTempNamespaceState(Oid *tempNamespaceId, Oid *tempToastNamespaceId)
3876 : : {
3877 : : /* Return namespace OIDs, or 0 if session has not created temp namespace */
3878 : 155 : *tempNamespaceId = myTempNamespace;
3879 : 155 : *tempToastNamespaceId = myTempToastNamespace;
3880 : 155 : }
3881 : :
3882 : : /*
3883 : : * SetTempNamespaceState - set status of session's temporary namespace
3884 : : *
3885 : : * This is used for conveying state to a parallel worker, and is not meant for
3886 : : * general-purpose access. By transferring these namespace OIDs to workers,
3887 : : * we ensure they will have the same notion of the search path as their leader
3888 : : * does.
3889 : : */
3890 : : void
3891 : 477 : SetTempNamespaceState(Oid tempNamespaceId, Oid tempToastNamespaceId)
3892 : : {
3893 : : /* Worker should not have created its own namespaces ... */
3894 [ + - ]: 477 : Assert(myTempNamespace == InvalidOid);
3895 [ + - ]: 477 : Assert(myTempToastNamespace == InvalidOid);
3896 [ + - ]: 477 : Assert(myTempNamespaceSubID == InvalidSubTransactionId);
3897 : :
3898 : : /* Assign same namespace OIDs that leader has */
3899 : 477 : myTempNamespace = tempNamespaceId;
3900 : 477 : myTempToastNamespace = tempToastNamespaceId;
3901 : :
3902 : : /*
3903 : : * It's fine to leave myTempNamespaceSubID == InvalidSubTransactionId.
3904 : : * Even if the namespace is new so far as the leader is concerned, it's
3905 : : * not new to the worker, and we certainly wouldn't want the worker trying
3906 : : * to destroy it.
3907 : : */
3908 : :
3909 : 477 : baseSearchPathValid = false; /* may need to rebuild list */
3910 : 477 : searchPathCacheValid = false;
3911 : 477 : }
3912 : :
3913 : :
3914 : : /*
3915 : : * GetSearchPathMatcher - fetch current search path definition.
3916 : : *
3917 : : * The result structure is allocated in the specified memory context
3918 : : * (which might or might not be equal to CurrentMemoryContext); but any
3919 : : * junk created by revalidation calculations will be in CurrentMemoryContext.
3920 : : */
3921 : : SearchPathMatcher *
3922 : 6037 : GetSearchPathMatcher(MemoryContext context)
3923 : : {
3924 : 6037 : SearchPathMatcher *result;
3925 : 6037 : List *schemas;
3926 : 6037 : MemoryContext oldcxt;
3927 : :
3928 : 6037 : recomputeNamespacePath();
3929 : :
3930 : 6037 : oldcxt = MemoryContextSwitchTo(context);
3931 : :
3932 : 6037 : result = palloc0_object(SearchPathMatcher);
3933 : 6037 : schemas = list_copy(activeSearchPath);
3934 [ - + + + ]: 14434 : while (schemas && linitial_oid(schemas) != activeCreationNamespace)
3935 : : {
3936 [ + + ]: 8397 : if (linitial_oid(schemas) == myTempNamespace)
3937 : 2389 : result->addTemp = true;
3938 : : else
3939 : : {
3940 [ - + ]: 6008 : Assert(linitial_oid(schemas) == PG_CATALOG_NAMESPACE);
3941 : 6008 : result->addCatalog = true;
3942 : : }
3943 : 8397 : schemas = list_delete_first(schemas);
3944 : : }
3945 : 6037 : result->schemas = schemas;
3946 : 6037 : result->generation = activePathGeneration;
3947 : :
3948 : 6037 : MemoryContextSwitchTo(oldcxt);
3949 : :
3950 : 12074 : return result;
3951 : 6037 : }
3952 : :
3953 : : /*
3954 : : * CopySearchPathMatcher - copy the specified SearchPathMatcher.
3955 : : *
3956 : : * The result structure is allocated in CurrentMemoryContext.
3957 : : */
3958 : : SearchPathMatcher *
3959 : 0 : CopySearchPathMatcher(SearchPathMatcher *path)
3960 : : {
3961 : 0 : SearchPathMatcher *result;
3962 : :
3963 : 0 : result = palloc_object(SearchPathMatcher);
3964 : 0 : result->schemas = list_copy(path->schemas);
3965 : 0 : result->addCatalog = path->addCatalog;
3966 : 0 : result->addTemp = path->addTemp;
3967 : 0 : result->generation = path->generation;
3968 : :
3969 : 0 : return result;
3970 : 0 : }
3971 : :
3972 : : /*
3973 : : * SearchPathMatchesCurrentEnvironment - does path match current environment?
3974 : : *
3975 : : * This is tested over and over in some common code paths, and in the typical
3976 : : * scenario where the active search path seldom changes, it'll always succeed.
3977 : : * We make that case fast by keeping a generation counter that is advanced
3978 : : * whenever the active search path changes.
3979 : : */
3980 : : bool
3981 : 464369 : SearchPathMatchesCurrentEnvironment(SearchPathMatcher *path)
3982 : : {
3983 : 464369 : ListCell *lc,
3984 : : *lcp;
3985 : :
3986 : 464369 : recomputeNamespacePath();
3987 : :
3988 : : /* Quick out if already known equal to active path. */
3989 [ + + ]: 464369 : if (path->generation == activePathGeneration)
3990 : 464328 : return true;
3991 : :
3992 : : /* We scan down the activeSearchPath to see if it matches the input. */
3993 : 41 : lc = list_head(activeSearchPath);
3994 : :
3995 : : /* If path->addTemp, first item should be my temp namespace. */
3996 [ + + ]: 41 : if (path->addTemp)
3997 : : {
3998 [ + - - + ]: 7 : if (lc && lfirst_oid(lc) == myTempNamespace)
3999 : 7 : lc = lnext(activeSearchPath, lc);
4000 : : else
4001 : 0 : return false;
4002 : 7 : }
4003 : : /* If path->addCatalog, next item should be pg_catalog. */
4004 [ + + ]: 41 : if (path->addCatalog)
4005 : : {
4006 [ + - - + ]: 25 : if (lc && lfirst_oid(lc) == PG_CATALOG_NAMESPACE)
4007 : 25 : lc = lnext(activeSearchPath, lc);
4008 : : else
4009 : 0 : return false;
4010 : 25 : }
4011 : : /* We should now be looking at the activeCreationNamespace. */
4012 [ + + + + ]: 41 : if (activeCreationNamespace != (lc ? lfirst_oid(lc) : InvalidOid))
4013 : 2 : return false;
4014 : : /* The remainder of activeSearchPath should match path->schemas. */
4015 [ + - + + : 98 : foreach(lcp, path->schemas)
+ + + + ]
4016 : : {
4017 [ + - + + ]: 59 : if (lc && lfirst_oid(lc) == lfirst_oid(lcp))
4018 : 56 : lc = lnext(activeSearchPath, lc);
4019 : : else
4020 : 3 : return false;
4021 : 56 : }
4022 [ - + ]: 36 : if (lc)
4023 : 0 : return false;
4024 : :
4025 : : /*
4026 : : * Update path->generation so that future tests will return quickly, so
4027 : : * long as the active search path doesn't change.
4028 : : */
4029 : 36 : path->generation = activePathGeneration;
4030 : :
4031 : 36 : return true;
4032 : 464369 : }
4033 : :
4034 : : /*
4035 : : * get_collation_oid - find a collation by possibly qualified name
4036 : : *
4037 : : * Note that this will only find collations that work with the current
4038 : : * database's encoding.
4039 : : */
4040 : : Oid
4041 : 1738 : get_collation_oid(List *collname, bool missing_ok)
4042 : : {
4043 : 1738 : char *schemaname;
4044 : 1738 : char *collation_name;
4045 : 1738 : int32 dbencoding = GetDatabaseEncoding();
4046 : 1738 : Oid namespaceId;
4047 : 1738 : Oid colloid;
4048 : 1738 : ListCell *l;
4049 : :
4050 : : /* deconstruct the name list */
4051 : 1738 : DeconstructQualifiedName(collname, &schemaname, &collation_name);
4052 : :
4053 [ + + ]: 1738 : if (schemaname)
4054 : : {
4055 : : /* use exact schema given */
4056 : 1114 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
4057 [ + + + + ]: 1114 : if (missing_ok && !OidIsValid(namespaceId))
4058 : 4 : return InvalidOid;
4059 : :
4060 : 1110 : colloid = lookup_collation(collation_name, namespaceId, dbencoding);
4061 [ - + ]: 1110 : if (OidIsValid(colloid))
4062 : 1110 : return colloid;
4063 : 0 : }
4064 : : else
4065 : : {
4066 : : /* search for it in search path */
4067 : 624 : recomputeNamespacePath();
4068 : :
4069 [ + - + + : 1675 : foreach(l, activeSearchPath)
+ + + + ]
4070 : : {
4071 : 1051 : namespaceId = lfirst_oid(l);
4072 : :
4073 [ + + ]: 1051 : if (namespaceId == myTempNamespace)
4074 : 219 : continue; /* do not look in temp namespace */
4075 : :
4076 : 832 : colloid = lookup_collation(collation_name, namespaceId, dbencoding);
4077 [ + + ]: 832 : if (OidIsValid(colloid))
4078 : 616 : return colloid;
4079 : 216 : }
4080 : : }
4081 : :
4082 : : /* Not found in path */
4083 [ + + ]: 8 : if (!missing_ok)
4084 [ + - + - ]: 5 : ereport(ERROR,
4085 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
4086 : : errmsg("collation \"%s\" for encoding \"%s\" does not exist",
4087 : : NameListToString(collname), GetDatabaseEncodingName())));
4088 : 3 : return InvalidOid;
4089 : 1733 : }
4090 : :
4091 : : /*
4092 : : * get_conversion_oid - find a conversion by possibly qualified name
4093 : : */
4094 : : Oid
4095 : 34 : get_conversion_oid(List *conname, bool missing_ok)
4096 : : {
4097 : 34 : char *schemaname;
4098 : 34 : char *conversion_name;
4099 : 34 : Oid namespaceId;
4100 : 34 : Oid conoid = InvalidOid;
4101 : 34 : ListCell *l;
4102 : :
4103 : : /* deconstruct the name list */
4104 : 34 : DeconstructQualifiedName(conname, &schemaname, &conversion_name);
4105 : :
4106 [ + + ]: 34 : if (schemaname)
4107 : : {
4108 : : /* use exact schema given */
4109 : 8 : namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
4110 [ + + + - ]: 8 : if (missing_ok && !OidIsValid(namespaceId))
4111 : 1 : conoid = InvalidOid;
4112 : : else
4113 : 7 : conoid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
4114 : : PointerGetDatum(conversion_name),
4115 : : ObjectIdGetDatum(namespaceId));
4116 : 8 : }
4117 : : else
4118 : : {
4119 : : /* search for it in search path */
4120 : 26 : recomputeNamespacePath();
4121 : :
4122 [ + - + + : 78 : foreach(l, activeSearchPath)
+ + + + ]
4123 : : {
4124 : 52 : namespaceId = lfirst_oid(l);
4125 : :
4126 [ - + ]: 52 : if (namespaceId == myTempNamespace)
4127 : 0 : continue; /* do not look in temp namespace */
4128 : :
4129 : 52 : conoid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
4130 : : PointerGetDatum(conversion_name),
4131 : : ObjectIdGetDatum(namespaceId));
4132 [ + + ]: 52 : if (OidIsValid(conoid))
4133 : 21 : return conoid;
4134 : 31 : }
4135 : : }
4136 : :
4137 : : /* Not found in path */
4138 [ + + + + ]: 13 : if (!OidIsValid(conoid) && !missing_ok)
4139 [ + - + - ]: 6 : ereport(ERROR,
4140 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
4141 : : errmsg("conversion \"%s\" does not exist",
4142 : : NameListToString(conname))));
4143 : 7 : return conoid;
4144 : 28 : }
4145 : :
4146 : : /*
4147 : : * FindDefaultConversionProc - find default encoding conversion proc
4148 : : */
4149 : : Oid
4150 : 1096 : FindDefaultConversionProc(int32 for_encoding, int32 to_encoding)
4151 : : {
4152 : 1096 : Oid proc;
4153 : 1096 : ListCell *l;
4154 : :
4155 : 1096 : recomputeNamespacePath();
4156 : :
4157 [ + - - + : 2192 : foreach(l, activeSearchPath)
- + + - ]
4158 : : {
4159 : 1096 : Oid namespaceId = lfirst_oid(l);
4160 : :
4161 [ - + ]: 1096 : if (namespaceId == myTempNamespace)
4162 : 0 : continue; /* do not look in temp namespace */
4163 : :
4164 : 1096 : proc = FindDefaultConversion(namespaceId, for_encoding, to_encoding);
4165 [ + - ]: 1096 : if (OidIsValid(proc))
4166 : 1096 : return proc;
4167 [ - + - ]: 1096 : }
4168 : :
4169 : : /* Not found in path */
4170 : 0 : return InvalidOid;
4171 : 1096 : }
4172 : :
4173 : : /*
4174 : : * Look up namespace IDs and perform ACL checks. Return newly-allocated list.
4175 : : */
4176 : : static List *
4177 : 3952 : preprocessNamespacePath(const char *searchPath, Oid roleid,
4178 : : bool *temp_missing)
4179 : : {
4180 : 3952 : char *rawname;
4181 : 3952 : List *namelist;
4182 : 3952 : List *oidlist;
4183 : 3952 : ListCell *l;
4184 : :
4185 : : /* Need a modifiable copy */
4186 : 3952 : rawname = pstrdup(searchPath);
4187 : :
4188 : : /* Parse string into list of identifiers */
4189 [ + - ]: 3952 : if (!SplitIdentifierString(rawname, ',', &namelist))
4190 : : {
4191 : : /* syntax error in name list */
4192 : : /* this should not happen if GUC checked check_search_path */
4193 [ # # # # ]: 0 : elog(ERROR, "invalid list syntax");
4194 : 0 : }
4195 : :
4196 : : /*
4197 : : * Convert the list of names to a list of OIDs. If any names are not
4198 : : * recognizable or we don't have read access, just leave them out of the
4199 : : * list. (We can't raise an error, since the search_path setting has
4200 : : * already been accepted.) Don't make duplicate entries, either.
4201 : : */
4202 : 3952 : oidlist = NIL;
4203 : 3952 : *temp_missing = false;
4204 [ + - + + : 11475 : foreach(l, namelist)
+ + ]
4205 : : {
4206 : 7523 : char *curname = (char *) lfirst(l);
4207 : 7523 : Oid namespaceId;
4208 : :
4209 [ + + ]: 7523 : if (strcmp(curname, "$user") == 0)
4210 : : {
4211 : : /* $user --- substitute namespace matching user name, if any */
4212 : 3255 : HeapTuple tuple;
4213 : :
4214 : 3255 : tuple = SearchSysCache1(AUTHOID, ObjectIdGetDatum(roleid));
4215 [ - + ]: 3255 : if (HeapTupleIsValid(tuple))
4216 : : {
4217 : 3255 : char *rname;
4218 : :
4219 : 3255 : rname = NameStr(((Form_pg_authid) GETSTRUCT(tuple))->rolname);
4220 : 3255 : namespaceId = get_namespace_oid(rname, true);
4221 : 3255 : ReleaseSysCache(tuple);
4222 [ + + - + ]: 3255 : if (OidIsValid(namespaceId) &&
4223 : 2 : object_aclcheck(NamespaceRelationId, namespaceId, roleid,
4224 : 2 : ACL_USAGE) == ACLCHECK_OK)
4225 : 2 : oidlist = lappend_oid(oidlist, namespaceId);
4226 : 3255 : }
4227 : 3255 : }
4228 [ + + ]: 4268 : else if (strcmp(curname, "pg_temp") == 0)
4229 : : {
4230 : : /* pg_temp --- substitute temp namespace, if any */
4231 [ + + ]: 117 : if (OidIsValid(myTempNamespace))
4232 : 54 : oidlist = lappend_oid(oidlist, myTempNamespace);
4233 : : else
4234 : : {
4235 : : /* If it ought to be the creation namespace, set flag */
4236 [ + + ]: 63 : if (oidlist == NIL)
4237 : 3 : *temp_missing = true;
4238 : : }
4239 : 117 : }
4240 : : else
4241 : : {
4242 : : /* normal namespace reference */
4243 : 4151 : namespaceId = get_namespace_oid(curname, true);
4244 [ + + + + ]: 4151 : if (OidIsValid(namespaceId) &&
4245 : 4140 : object_aclcheck(NamespaceRelationId, namespaceId, roleid,
4246 : 4140 : ACL_USAGE) == ACLCHECK_OK)
4247 : 4139 : oidlist = lappend_oid(oidlist, namespaceId);
4248 : : }
4249 : 7523 : }
4250 : :
4251 : 3952 : pfree(rawname);
4252 : 3952 : list_free(namelist);
4253 : :
4254 : 7904 : return oidlist;
4255 : 3952 : }
4256 : :
4257 : : /*
4258 : : * Remove duplicates, run namespace search hooks, and prepend
4259 : : * implicitly-searched namespaces. Return newly-allocated list.
4260 : : *
4261 : : * If an object_access_hook is present, this must always be recalculated. It
4262 : : * may seem that duplicate elimination is not dependent on the result of the
4263 : : * hook, but if a hook returns different results on different calls for the
4264 : : * same namespace ID, then it could affect the order in which that namespace
4265 : : * appears in the final list.
4266 : : */
4267 : : static List *
4268 : 3952 : finalNamespacePath(List *oidlist, Oid *firstNS)
4269 : : {
4270 : 3952 : List *finalPath = NIL;
4271 : 3952 : ListCell *lc;
4272 : :
4273 [ + + + + : 8147 : foreach(lc, oidlist)
+ + ]
4274 : : {
4275 : 4195 : Oid namespaceId = lfirst_oid(lc);
4276 : :
4277 [ - + ]: 4195 : if (!list_member_oid(finalPath, namespaceId))
4278 : : {
4279 [ + - # # ]: 4195 : if (InvokeNamespaceSearchHook(namespaceId, false))
4280 : 4195 : finalPath = lappend_oid(finalPath, namespaceId);
4281 : 4195 : }
4282 : 4195 : }
4283 : :
4284 : : /*
4285 : : * Remember the first member of the explicit list. (Note: this is
4286 : : * nominally wrong if temp_missing, but we need it anyway to distinguish
4287 : : * explicit from implicit mention of pg_catalog.)
4288 : : */
4289 [ + + ]: 3952 : if (finalPath == NIL)
4290 : 4 : *firstNS = InvalidOid;
4291 : : else
4292 : 3948 : *firstNS = linitial_oid(finalPath);
4293 : :
4294 : : /*
4295 : : * Add any implicitly-searched namespaces to the list. Note these go on
4296 : : * the front, not the back; also notice that we do not check USAGE
4297 : : * permissions for these.
4298 : : */
4299 [ + + ]: 3952 : if (!list_member_oid(finalPath, PG_CATALOG_NAMESPACE))
4300 : 3842 : finalPath = lcons_oid(PG_CATALOG_NAMESPACE, finalPath);
4301 : :
4302 [ + + + + ]: 3952 : if (OidIsValid(myTempNamespace) &&
4303 : 792 : !list_member_oid(finalPath, myTempNamespace))
4304 : 738 : finalPath = lcons_oid(myTempNamespace, finalPath);
4305 : :
4306 : 7904 : return finalPath;
4307 : 3952 : }
4308 : :
4309 : : /*
4310 : : * Retrieve search path information from the cache; or if not there, fill
4311 : : * it. The returned entry is valid only until the next call to this function.
4312 : : */
4313 : : static const SearchPathCacheEntry *
4314 : 8067 : cachedNamespacePath(const char *searchPath, Oid roleid)
4315 : : {
4316 : 8067 : MemoryContext oldcxt;
4317 : 8067 : SearchPathCacheEntry *entry;
4318 : :
4319 : 8067 : spcache_init();
4320 : :
4321 : 8067 : entry = spcache_insert(searchPath, roleid);
4322 : :
4323 : : /*
4324 : : * An OOM may have resulted in a cache entry with missing 'oidlist' or
4325 : : * 'finalPath', so just compute whatever is missing.
4326 : : */
4327 : :
4328 [ + + ]: 8067 : if (entry->oidlist == NIL)
4329 : : {
4330 : 3952 : oldcxt = MemoryContextSwitchTo(SearchPathCacheContext);
4331 : 7904 : entry->oidlist = preprocessNamespacePath(searchPath, roleid,
4332 : 3952 : &entry->temp_missing);
4333 : 3952 : MemoryContextSwitchTo(oldcxt);
4334 : 3952 : }
4335 : :
4336 : : /*
4337 : : * If a hook is set, we must recompute finalPath from the oidlist each
4338 : : * time, because the hook may affect the result. This is still much faster
4339 : : * than recomputing from the string (and doing catalog lookups and ACL
4340 : : * checks).
4341 : : */
4342 [ + + + - : 8067 : if (entry->finalPath == NIL || object_access_hook ||
+ - ]
4343 : 4115 : entry->forceRecompute)
4344 : : {
4345 : 3952 : list_free(entry->finalPath);
4346 : 3952 : entry->finalPath = NIL;
4347 : :
4348 : 3952 : oldcxt = MemoryContextSwitchTo(SearchPathCacheContext);
4349 : 7904 : entry->finalPath = finalNamespacePath(entry->oidlist,
4350 : 3952 : &entry->firstNS);
4351 : 3952 : MemoryContextSwitchTo(oldcxt);
4352 : :
4353 : : /*
4354 : : * If an object_access_hook is set when finalPath is calculated, the
4355 : : * result may be affected by the hook. Force recomputation of
4356 : : * finalPath the next time this cache entry is used, even if the
4357 : : * object_access_hook is not set at that time.
4358 : : */
4359 : 3952 : entry->forceRecompute = object_access_hook ? true : false;
4360 : 3952 : }
4361 : :
4362 : 16134 : return entry;
4363 : 8067 : }
4364 : :
4365 : : /*
4366 : : * recomputeNamespacePath - recompute path derived variables if needed.
4367 : : */
4368 : : static void
4369 : 714694 : recomputeNamespacePath(void)
4370 : : {
4371 : 714694 : Oid roleid = GetUserId();
4372 : 714694 : bool pathChanged;
4373 : 714694 : const SearchPathCacheEntry *entry;
4374 : :
4375 : : /* Do nothing if path is already valid. */
4376 [ + + + + ]: 714694 : if (baseSearchPathValid && namespaceUser == roleid)
4377 : 706627 : return;
4378 : :
4379 : 8067 : entry = cachedNamespacePath(namespace_search_path, roleid);
4380 : :
4381 [ + + ]: 8067 : if (baseCreationNamespace == entry->firstNS &&
4382 [ + + + + ]: 7305 : baseTempCreationPending == entry->temp_missing &&
4383 : 7302 : equal(entry->finalPath, baseSearchPath))
4384 : : {
4385 : 7213 : pathChanged = false;
4386 : 7213 : }
4387 : : else
4388 : : {
4389 : 854 : MemoryContext oldcxt;
4390 : 854 : List *newpath;
4391 : :
4392 : 854 : pathChanged = true;
4393 : :
4394 : : /* Must save OID list in permanent storage. */
4395 : 854 : oldcxt = MemoryContextSwitchTo(TopMemoryContext);
4396 : 854 : newpath = list_copy(entry->finalPath);
4397 : 854 : MemoryContextSwitchTo(oldcxt);
4398 : :
4399 : : /* Now safe to assign to state variables. */
4400 : 854 : list_free(baseSearchPath);
4401 : 854 : baseSearchPath = newpath;
4402 : 854 : baseCreationNamespace = entry->firstNS;
4403 : 854 : baseTempCreationPending = entry->temp_missing;
4404 : 854 : }
4405 : :
4406 : : /* Mark the path valid. */
4407 : 8067 : baseSearchPathValid = true;
4408 : 8067 : namespaceUser = roleid;
4409 : :
4410 : : /* And make it active. */
4411 : 8067 : activeSearchPath = baseSearchPath;
4412 : 8067 : activeCreationNamespace = baseCreationNamespace;
4413 : 8067 : activeTempCreationPending = baseTempCreationPending;
4414 : :
4415 : : /*
4416 : : * Bump the generation only if something actually changed. (Notice that
4417 : : * what we compared to was the old state of the base path variables.)
4418 : : */
4419 [ + + ]: 8067 : if (pathChanged)
4420 : 854 : activePathGeneration++;
4421 [ - + ]: 714694 : }
4422 : :
4423 : : /*
4424 : : * AccessTempTableNamespace
4425 : : * Provide access to a temporary namespace, potentially creating it
4426 : : * if not present yet. This routine registers if the namespace gets
4427 : : * in use in this transaction. 'force' can be set to true to allow
4428 : : * the caller to enforce the creation of the temporary namespace for
4429 : : * use in this backend, which happens if its creation is pending.
4430 : : */
4431 : : static void
4432 : 1138 : AccessTempTableNamespace(bool force)
4433 : : {
4434 : : /*
4435 : : * Make note that this temporary namespace has been accessed in this
4436 : : * transaction.
4437 : : */
4438 : 1138 : MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;
4439 : :
4440 : : /*
4441 : : * If the caller attempting to access a temporary schema expects the
4442 : : * creation of the namespace to be pending and should be enforced, then go
4443 : : * through the creation.
4444 : : */
4445 [ + + + + ]: 1138 : if (!force && OidIsValid(myTempNamespace))
4446 : 1041 : return;
4447 : :
4448 : : /*
4449 : : * The temporary tablespace does not exist yet and is wanted, so
4450 : : * initialize it.
4451 : : */
4452 : 97 : InitTempTableNamespace();
4453 : 1138 : }
4454 : :
4455 : : /*
4456 : : * InitTempTableNamespace
4457 : : * Initialize temp table namespace on first use in a particular backend
4458 : : */
4459 : : static void
4460 : 97 : InitTempTableNamespace(void)
4461 : : {
4462 : 97 : char namespaceName[NAMEDATALEN];
4463 : 97 : Oid namespaceId;
4464 : 97 : Oid toastspaceId;
4465 : :
4466 [ + - ]: 97 : Assert(!OidIsValid(myTempNamespace));
4467 : :
4468 : : /*
4469 : : * First, do permission check to see if we are authorized to make temp
4470 : : * tables. We use a nonstandard error message here since "databasename:
4471 : : * permission denied" might be a tad cryptic.
4472 : : *
4473 : : * Note that ACL_CREATE_TEMP rights are rechecked in pg_namespace_aclmask;
4474 : : * that's necessary since current user ID could change during the session.
4475 : : * But there's no need to make the namespace in the first place until a
4476 : : * temp table creation request is made by someone with appropriate rights.
4477 : : */
4478 : 97 : if (object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(),
4479 [ + - ]: 97 : ACL_CREATE_TEMP) != ACLCHECK_OK)
4480 [ # # # # ]: 0 : ereport(ERROR,
4481 : : (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
4482 : : errmsg("permission denied to create temporary tables in database \"%s\"",
4483 : : get_database_name(MyDatabaseId))));
4484 : :
4485 : : /*
4486 : : * Do not allow a Hot Standby session to make temp tables. Aside from
4487 : : * problems with modifying the system catalogs, there is a naming
4488 : : * conflict: pg_temp_N belongs to the session with proc number N on the
4489 : : * primary, not to a hot standby session with the same proc number. We
4490 : : * should not be able to get here anyway due to XactReadOnly checks, but
4491 : : * let's just make real sure. Note that this also backstops various
4492 : : * operations that allow XactReadOnly transactions to modify temp tables;
4493 : : * they'd need RecoveryInProgress checks if not for this.
4494 : : */
4495 [ + - ]: 97 : if (RecoveryInProgress())
4496 [ # # # # ]: 0 : ereport(ERROR,
4497 : : (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
4498 : : errmsg("cannot create temporary tables during recovery")));
4499 : :
4500 : : /* Parallel workers can't create temporary tables, either. */
4501 [ + - ]: 97 : if (IsParallelWorker())
4502 [ # # # # ]: 0 : ereport(ERROR,
4503 : : (errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
4504 : : errmsg("cannot create temporary tables during a parallel operation")));
4505 : :
4506 : 97 : snprintf(namespaceName, sizeof(namespaceName), "pg_temp_%d", MyProcNumber);
4507 : :
4508 : 97 : namespaceId = get_namespace_oid(namespaceName, true);
4509 [ + + ]: 97 : if (!OidIsValid(namespaceId))
4510 : : {
4511 : : /*
4512 : : * First use of this temp namespace in this database; create it. The
4513 : : * temp namespaces are always owned by the superuser. We leave their
4514 : : * permissions at default --- i.e., no access except to superuser ---
4515 : : * to ensure that unprivileged users can't peek at other backends'
4516 : : * temp tables. This works because the places that access the temp
4517 : : * namespace for my own backend skip permissions checks on it.
4518 : : */
4519 : 72 : namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID,
4520 : : true);
4521 : : /* Advance command counter to make namespace visible */
4522 : 72 : CommandCounterIncrement();
4523 : 72 : }
4524 : : else
4525 : : {
4526 : : /*
4527 : : * If the namespace already exists, clean it out (in case the former
4528 : : * owner crashed without doing so).
4529 : : */
4530 : 25 : RemoveTempRelations(namespaceId);
4531 : : }
4532 : :
4533 : : /*
4534 : : * If the corresponding toast-table namespace doesn't exist yet, create
4535 : : * it. (We assume there is no need to clean it out if it does exist, since
4536 : : * dropping a parent table should make its toast table go away.)
4537 : : */
4538 : 194 : snprintf(namespaceName, sizeof(namespaceName), "pg_toast_temp_%d",
4539 : 97 : MyProcNumber);
4540 : :
4541 : 97 : toastspaceId = get_namespace_oid(namespaceName, true);
4542 [ + + ]: 97 : if (!OidIsValid(toastspaceId))
4543 : : {
4544 : 72 : toastspaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID,
4545 : : true);
4546 : : /* Advance command counter to make namespace visible */
4547 : 72 : CommandCounterIncrement();
4548 : 72 : }
4549 : :
4550 : : /*
4551 : : * Okay, we've prepared the temp namespace ... but it's not committed yet,
4552 : : * so all our work could be undone by transaction rollback. Set flag for
4553 : : * AtEOXact_Namespace to know what to do.
4554 : : */
4555 : 97 : myTempNamespace = namespaceId;
4556 : 97 : myTempToastNamespace = toastspaceId;
4557 : :
4558 : : /*
4559 : : * Mark MyProc as owning this namespace which other processes can use to
4560 : : * decide if a temporary namespace is in use or not. We assume that
4561 : : * assignment of namespaceId is an atomic operation. Even if it is not,
4562 : : * the temporary relation which resulted in the creation of this temporary
4563 : : * namespace is still locked until the current transaction commits, and
4564 : : * its pg_namespace row is not visible yet. However it does not matter:
4565 : : * this flag makes the namespace as being in use, so no objects created on
4566 : : * it would be removed concurrently.
4567 : : */
4568 : 97 : MyProc->tempNamespaceId = namespaceId;
4569 : :
4570 : : /* It should not be done already. */
4571 [ + - ]: 97 : Assert(myTempNamespaceSubID == InvalidSubTransactionId);
4572 : 97 : myTempNamespaceSubID = GetCurrentSubTransactionId();
4573 : :
4574 : 97 : baseSearchPathValid = false; /* need to rebuild list */
4575 : 97 : searchPathCacheValid = false;
4576 : 97 : }
4577 : :
4578 : : /*
4579 : : * End-of-transaction cleanup for namespaces.
4580 : : */
4581 : : void
4582 : 57917 : AtEOXact_Namespace(bool isCommit, bool parallel)
4583 : : {
4584 : : /*
4585 : : * If we abort the transaction in which a temp namespace was selected,
4586 : : * we'll have to do any creation or cleanout work over again. So, just
4587 : : * forget the namespace entirely until next time. On the other hand, if
4588 : : * we commit then register an exit callback to clean out the temp tables
4589 : : * at backend shutdown. (We only want to register the callback once per
4590 : : * session, so this is a good place to do it.)
4591 : : */
4592 [ + + - + ]: 57917 : if (myTempNamespaceSubID != InvalidSubTransactionId && !parallel)
4593 : : {
4594 [ + + ]: 95 : if (isCommit)
4595 : 90 : before_shmem_exit(RemoveTempRelationsCallback, 0);
4596 : : else
4597 : : {
4598 : 5 : myTempNamespace = InvalidOid;
4599 : 5 : myTempToastNamespace = InvalidOid;
4600 : 5 : baseSearchPathValid = false; /* need to rebuild list */
4601 : 5 : searchPathCacheValid = false;
4602 : :
4603 : : /*
4604 : : * Reset the temporary namespace flag in MyProc. We assume that
4605 : : * this operation is atomic.
4606 : : *
4607 : : * Because this transaction is aborting, the pg_namespace row is
4608 : : * not visible to anyone else anyway, but that doesn't matter:
4609 : : * it's not a problem if objects contained in this namespace are
4610 : : * removed concurrently.
4611 : : */
4612 : 5 : MyProc->tempNamespaceId = InvalidOid;
4613 : : }
4614 : 95 : myTempNamespaceSubID = InvalidSubTransactionId;
4615 : 95 : }
4616 : :
4617 : 57917 : }
4618 : :
4619 : : /*
4620 : : * AtEOSubXact_Namespace
4621 : : *
4622 : : * At subtransaction commit, propagate the temp-namespace-creation
4623 : : * flag to the parent subtransaction.
4624 : : *
4625 : : * At subtransaction abort, forget the flag if we set it up.
4626 : : */
4627 : : void
4628 : 1665 : AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid,
4629 : : SubTransactionId parentSubid)
4630 : : {
4631 : :
4632 [ + + ]: 1665 : if (myTempNamespaceSubID == mySubid)
4633 : : {
4634 [ - + ]: 2 : if (isCommit)
4635 : 0 : myTempNamespaceSubID = parentSubid;
4636 : : else
4637 : : {
4638 : 2 : myTempNamespaceSubID = InvalidSubTransactionId;
4639 : : /* TEMP namespace creation failed, so reset state */
4640 : 2 : myTempNamespace = InvalidOid;
4641 : 2 : myTempToastNamespace = InvalidOid;
4642 : 2 : baseSearchPathValid = false; /* need to rebuild list */
4643 : 2 : searchPathCacheValid = false;
4644 : :
4645 : : /*
4646 : : * Reset the temporary namespace flag in MyProc. We assume that
4647 : : * this operation is atomic.
4648 : : *
4649 : : * Because this subtransaction is aborting, the pg_namespace row
4650 : : * is not visible to anyone else anyway, but that doesn't matter:
4651 : : * it's not a problem if objects contained in this namespace are
4652 : : * removed concurrently.
4653 : : */
4654 : 2 : MyProc->tempNamespaceId = InvalidOid;
4655 : : }
4656 : 2 : }
4657 : 1665 : }
4658 : :
4659 : : /*
4660 : : * Remove all relations in the specified temp namespace.
4661 : : *
4662 : : * This is called at backend shutdown (if we made any temp relations).
4663 : : * It is also called when we begin using a pre-existing temp namespace,
4664 : : * in order to clean out any relations that might have been created by
4665 : : * a crashed backend.
4666 : : */
4667 : : static void
4668 : 118 : RemoveTempRelations(Oid tempNamespaceId)
4669 : : {
4670 : 118 : ObjectAddress object;
4671 : :
4672 : : /*
4673 : : * We want to get rid of everything in the target namespace, but not the
4674 : : * namespace itself (deleting it only to recreate it later would be a
4675 : : * waste of cycles). Hence, specify SKIP_ORIGINAL. It's also an INTERNAL
4676 : : * deletion, and we want to not drop any extensions that might happen to
4677 : : * own temp objects.
4678 : : */
4679 : 118 : object.classId = NamespaceRelationId;
4680 : 118 : object.objectId = tempNamespaceId;
4681 : 118 : object.objectSubId = 0;
4682 : :
4683 : 118 : performDeletion(&object, DROP_CASCADE,
4684 : : PERFORM_DELETION_INTERNAL |
4685 : : PERFORM_DELETION_QUIETLY |
4686 : : PERFORM_DELETION_SKIP_ORIGINAL |
4687 : : PERFORM_DELETION_SKIP_EXTENSIONS);
4688 : 118 : }
4689 : :
4690 : : /*
4691 : : * Callback to remove temp relations at backend exit.
4692 : : */
4693 : : static void
4694 : 90 : RemoveTempRelationsCallback(int code, Datum arg)
4695 : : {
4696 [ - + ]: 90 : if (OidIsValid(myTempNamespace)) /* should always be true */
4697 : : {
4698 : : /* Need to ensure we have a usable transaction. */
4699 : 90 : AbortOutOfAnyTransaction();
4700 : 90 : StartTransactionCommand();
4701 : 90 : PushActiveSnapshot(GetTransactionSnapshot());
4702 : :
4703 : 90 : RemoveTempRelations(myTempNamespace);
4704 : :
4705 : 90 : PopActiveSnapshot();
4706 : 90 : CommitTransactionCommand();
4707 : 90 : }
4708 : 90 : }
4709 : :
4710 : : /*
4711 : : * Remove all temp tables from the temporary namespace.
4712 : : */
4713 : : void
4714 : 3 : ResetTempTableNamespace(void)
4715 : : {
4716 [ - + ]: 3 : if (OidIsValid(myTempNamespace))
4717 : 3 : RemoveTempRelations(myTempNamespace);
4718 : 3 : }
4719 : :
4720 : :
4721 : : /*
4722 : : * Routines for handling the GUC variable 'search_path'.
4723 : : */
4724 : :
4725 : : /* check_hook: validate new search_path value */
4726 : : bool
4727 : 13534 : check_search_path(char **newval, void **extra, GucSource source)
4728 : : {
4729 : 13534 : Oid roleid = InvalidOid;
4730 : 13534 : const char *searchPath = *newval;
4731 : 13534 : char *rawname;
4732 : 13534 : List *namelist;
4733 : 13534 : bool use_cache = (SearchPathCacheContext != NULL);
4734 : :
4735 : : /*
4736 : : * We used to try to check that the named schemas exist, but there are
4737 : : * many valid use-cases for having search_path settings that include
4738 : : * schemas that don't exist; and often, we are not inside a transaction
4739 : : * here and so can't consult the system catalogs anyway. So now, the only
4740 : : * requirement is syntactic validity of the identifier list.
4741 : : *
4742 : : * Checking only the syntactic validity also allows us to use the search
4743 : : * path cache (if available) to avoid calling SplitIdentifierString() on
4744 : : * the same string repeatedly.
4745 : : */
4746 [ + + ]: 13534 : if (use_cache)
4747 : : {
4748 : 13098 : spcache_init();
4749 : :
4750 : 13098 : roleid = GetUserId();
4751 : :
4752 [ + + ]: 13098 : if (spcache_lookup(searchPath, roleid) != NULL)
4753 : 12069 : return true;
4754 : 1029 : }
4755 : :
4756 : : /*
4757 : : * Ensure validity check succeeds before creating cache entry.
4758 : : */
4759 : :
4760 : 1465 : rawname = pstrdup(searchPath); /* need a modifiable copy */
4761 : :
4762 : : /* Parse string into list of identifiers */
4763 [ + - ]: 1465 : if (!SplitIdentifierString(rawname, ',', &namelist))
4764 : : {
4765 : : /* syntax error in name list */
4766 : 0 : GUC_check_errdetail("List syntax is invalid.");
4767 : 0 : pfree(rawname);
4768 : 0 : list_free(namelist);
4769 : 0 : return false;
4770 : : }
4771 : 1465 : pfree(rawname);
4772 : 1465 : list_free(namelist);
4773 : :
4774 : : /* OK to create empty cache entry */
4775 [ + + ]: 1465 : if (use_cache)
4776 : 1029 : (void) spcache_insert(searchPath, roleid);
4777 : :
4778 : 1465 : return true;
4779 : 13534 : }
4780 : :
4781 : : /* assign_hook: do extra actions as needed */
4782 : : void
4783 : 26964 : assign_search_path(const char *newval, void *extra)
4784 : : {
4785 : : /* don't access search_path during bootstrap */
4786 [ + - ]: 26964 : Assert(!IsBootstrapProcessingMode());
4787 : :
4788 : : /*
4789 : : * We mark the path as needing recomputation, but don't do anything until
4790 : : * it's needed. This avoids trying to do database access during GUC
4791 : : * initialization, or outside a transaction.
4792 : : *
4793 : : * This does not invalidate the search path cache, so if this value had
4794 : : * been previously set and no syscache invalidations happened,
4795 : : * recomputation may not be necessary.
4796 : : */
4797 : 26964 : baseSearchPathValid = false;
4798 : 26964 : }
4799 : :
4800 : : /*
4801 : : * InitializeSearchPath: initialize module during InitPostgres.
4802 : : *
4803 : : * This is called after we are up enough to be able to do catalog lookups.
4804 : : */
4805 : : void
4806 : 797 : InitializeSearchPath(void)
4807 : : {
4808 [ + + ]: 797 : if (IsBootstrapProcessingMode())
4809 : : {
4810 : : /*
4811 : : * In bootstrap mode, the search path must be 'pg_catalog' so that
4812 : : * tables are created in the proper namespace; ignore the GUC setting.
4813 : : */
4814 : 1 : MemoryContext oldcxt;
4815 : :
4816 : 1 : oldcxt = MemoryContextSwitchTo(TopMemoryContext);
4817 : 1 : baseSearchPath = list_make1_oid(PG_CATALOG_NAMESPACE);
4818 : 1 : MemoryContextSwitchTo(oldcxt);
4819 : 1 : baseCreationNamespace = PG_CATALOG_NAMESPACE;
4820 : 1 : baseTempCreationPending = false;
4821 : 1 : baseSearchPathValid = true;
4822 : 1 : namespaceUser = GetUserId();
4823 : 1 : activeSearchPath = baseSearchPath;
4824 : 1 : activeCreationNamespace = baseCreationNamespace;
4825 : 1 : activeTempCreationPending = baseTempCreationPending;
4826 : 1 : activePathGeneration++; /* pro forma */
4827 : 1 : }
4828 : : else
4829 : : {
4830 : : /*
4831 : : * In normal mode, arrange for a callback on any syscache invalidation
4832 : : * that will affect the search_path cache.
4833 : : */
4834 : :
4835 : : /* namespace name or ACLs may have changed */
4836 : 796 : CacheRegisterSyscacheCallback(NAMESPACEOID,
4837 : : InvalidationCallback,
4838 : : (Datum) 0);
4839 : :
4840 : : /* role name may affect the meaning of "$user" */
4841 : 796 : CacheRegisterSyscacheCallback(AUTHOID,
4842 : : InvalidationCallback,
4843 : : (Datum) 0);
4844 : :
4845 : : /* role membership may affect ACLs */
4846 : 796 : CacheRegisterSyscacheCallback(AUTHMEMROLEMEM,
4847 : : InvalidationCallback,
4848 : : (Datum) 0);
4849 : :
4850 : : /* database owner may affect ACLs */
4851 : 796 : CacheRegisterSyscacheCallback(DATABASEOID,
4852 : : InvalidationCallback,
4853 : : (Datum) 0);
4854 : :
4855 : : /* Force search path to be recomputed on next use */
4856 : 796 : baseSearchPathValid = false;
4857 : 796 : searchPathCacheValid = false;
4858 : : }
4859 : 797 : }
4860 : :
4861 : : /*
4862 : : * InvalidationCallback
4863 : : * Syscache inval callback function
4864 : : */
4865 : : static void
4866 : 11441 : InvalidationCallback(Datum arg, int cacheid, uint32 hashvalue)
4867 : : {
4868 : : /*
4869 : : * Force search path to be recomputed on next use, also invalidating the
4870 : : * search path cache (because namespace names, ACLs, or role names may
4871 : : * have changed).
4872 : : */
4873 : 11441 : baseSearchPathValid = false;
4874 : 11441 : searchPathCacheValid = false;
4875 : 11441 : }
4876 : :
4877 : : /*
4878 : : * Fetch the active search path. The return value is a palloc'ed list
4879 : : * of OIDs; the caller is responsible for freeing this storage as
4880 : : * appropriate.
4881 : : *
4882 : : * The returned list includes the implicitly-prepended namespaces only if
4883 : : * includeImplicit is true.
4884 : : *
4885 : : * Note: calling this may result in a CommandCounterIncrement operation,
4886 : : * if we have to create or clean out the temp namespace.
4887 : : */
4888 : : List *
4889 : 20 : fetch_search_path(bool includeImplicit)
4890 : : {
4891 : 20 : List *result;
4892 : :
4893 : 20 : recomputeNamespacePath();
4894 : :
4895 : : /*
4896 : : * If the temp namespace should be first, force it to exist. This is so
4897 : : * that callers can trust the result to reflect the actual default
4898 : : * creation namespace. It's a bit bogus to do this here, since
4899 : : * current_schema() is supposedly a stable function without side-effects,
4900 : : * but the alternatives seem worse.
4901 : : */
4902 [ + + ]: 20 : if (activeTempCreationPending)
4903 : : {
4904 : 1 : AccessTempTableNamespace(true);
4905 : 1 : recomputeNamespacePath();
4906 : 1 : }
4907 : :
4908 : 20 : result = list_copy(activeSearchPath);
4909 [ + + ]: 20 : if (!includeImplicit)
4910 : : {
4911 [ + + + + ]: 32 : while (result && linitial_oid(result) != activeCreationNamespace)
4912 : 19 : result = list_delete_first(result);
4913 : 13 : }
4914 : :
4915 : 40 : return result;
4916 : 20 : }
4917 : :
4918 : : /*
4919 : : * Fetch the active search path into a caller-allocated array of OIDs.
4920 : : * Returns the number of path entries. (If this is more than sarray_len,
4921 : : * then the data didn't fit and is not all stored.)
4922 : : *
4923 : : * The returned list always includes the implicitly-prepended namespaces,
4924 : : * but never includes the temp namespace. (This is suitable for existing
4925 : : * users, which would want to ignore the temp namespace anyway.) This
4926 : : * definition allows us to not worry about initializing the temp namespace.
4927 : : */
4928 : : int
4929 : 64241 : fetch_search_path_array(Oid *sarray, int sarray_len)
4930 : : {
4931 : 64241 : int count = 0;
4932 : 64241 : ListCell *l;
4933 : :
4934 : 64241 : recomputeNamespacePath();
4935 : :
4936 [ + - + + : 225940 : foreach(l, activeSearchPath)
+ + ]
4937 : : {
4938 : 161699 : Oid namespaceId = lfirst_oid(l);
4939 : :
4940 [ + + ]: 161699 : if (namespaceId == myTempNamespace)
4941 : 30928 : continue; /* do not include temp namespace */
4942 : :
4943 [ - + ]: 130771 : if (count < sarray_len)
4944 : 130771 : sarray[count] = namespaceId;
4945 : 130771 : count++;
4946 [ - + + ]: 161699 : }
4947 : :
4948 : 128482 : return count;
4949 : 64241 : }
4950 : :
4951 : :
4952 : : /*
4953 : : * Export the FooIsVisible functions as SQL-callable functions.
4954 : : *
4955 : : * Note: as of Postgres 8.4, these will silently return NULL if called on
4956 : : * a nonexistent object OID, rather than failing. This is to avoid race
4957 : : * condition errors when a query that's scanning a catalog using an MVCC
4958 : : * snapshot uses one of these functions. The underlying IsVisible functions
4959 : : * always use an up-to-date snapshot and so might see the object as already
4960 : : * gone when it's still visible to the transaction snapshot.
4961 : : */
4962 : :
4963 : : Datum
4964 : 3808 : pg_table_is_visible(PG_FUNCTION_ARGS)
4965 : : {
4966 : 3808 : Oid oid = PG_GETARG_OID(0);
4967 : 3808 : bool result;
4968 : 3808 : bool is_missing = false;
4969 : :
4970 : 3808 : result = RelationIsVisibleExt(oid, &is_missing);
4971 : :
4972 [ + + ]: 3808 : if (is_missing)
4973 : 1 : PG_RETURN_NULL();
4974 : 3807 : PG_RETURN_BOOL(result);
4975 : 3808 : }
4976 : :
4977 : : Datum
4978 : 36 : pg_type_is_visible(PG_FUNCTION_ARGS)
4979 : : {
4980 : 36 : Oid oid = PG_GETARG_OID(0);
4981 : 36 : bool result;
4982 : 36 : bool is_missing = false;
4983 : :
4984 : 36 : result = TypeIsVisibleExt(oid, &is_missing);
4985 : :
4986 [ + - ]: 36 : if (is_missing)
4987 : 0 : PG_RETURN_NULL();
4988 : 36 : PG_RETURN_BOOL(result);
4989 : 36 : }
4990 : :
4991 : : Datum
4992 : 123 : pg_function_is_visible(PG_FUNCTION_ARGS)
4993 : : {
4994 : 123 : Oid oid = PG_GETARG_OID(0);
4995 : 123 : bool result;
4996 : 123 : bool is_missing = false;
4997 : :
4998 : 123 : result = FunctionIsVisibleExt(oid, &is_missing);
4999 : :
5000 [ + - ]: 123 : if (is_missing)
5001 : 0 : PG_RETURN_NULL();
5002 : 123 : PG_RETURN_BOOL(result);
5003 : 123 : }
5004 : :
5005 : : Datum
5006 : 17 : pg_operator_is_visible(PG_FUNCTION_ARGS)
5007 : : {
5008 : 17 : Oid oid = PG_GETARG_OID(0);
5009 : 17 : bool result;
5010 : 17 : bool is_missing = false;
5011 : :
5012 : 17 : result = OperatorIsVisibleExt(oid, &is_missing);
5013 : :
5014 [ + - ]: 17 : if (is_missing)
5015 : 0 : PG_RETURN_NULL();
5016 : 17 : PG_RETURN_BOOL(result);
5017 : 17 : }
5018 : :
5019 : : Datum
5020 : 3 : pg_opclass_is_visible(PG_FUNCTION_ARGS)
5021 : : {
5022 : 3 : Oid oid = PG_GETARG_OID(0);
5023 : 3 : bool result;
5024 : 3 : bool is_missing = false;
5025 : :
5026 : 3 : result = OpclassIsVisibleExt(oid, &is_missing);
5027 : :
5028 [ + - ]: 3 : if (is_missing)
5029 : 0 : PG_RETURN_NULL();
5030 : 3 : PG_RETURN_BOOL(result);
5031 : 3 : }
5032 : :
5033 : : Datum
5034 : 53 : pg_opfamily_is_visible(PG_FUNCTION_ARGS)
5035 : : {
5036 : 53 : Oid oid = PG_GETARG_OID(0);
5037 : 53 : bool result;
5038 : 53 : bool is_missing = false;
5039 : :
5040 : 53 : result = OpfamilyIsVisibleExt(oid, &is_missing);
5041 : :
5042 [ + - ]: 53 : if (is_missing)
5043 : 0 : PG_RETURN_NULL();
5044 : 53 : PG_RETURN_BOOL(result);
5045 : 53 : }
5046 : :
5047 : : Datum
5048 : 0 : pg_collation_is_visible(PG_FUNCTION_ARGS)
5049 : : {
5050 : 0 : Oid oid = PG_GETARG_OID(0);
5051 : 0 : bool result;
5052 : 0 : bool is_missing = false;
5053 : :
5054 : 0 : result = CollationIsVisibleExt(oid, &is_missing);
5055 : :
5056 [ # # ]: 0 : if (is_missing)
5057 : 0 : PG_RETURN_NULL();
5058 : 0 : PG_RETURN_BOOL(result);
5059 : 0 : }
5060 : :
5061 : : Datum
5062 : 0 : pg_conversion_is_visible(PG_FUNCTION_ARGS)
5063 : : {
5064 : 0 : Oid oid = PG_GETARG_OID(0);
5065 : 0 : bool result;
5066 : 0 : bool is_missing = false;
5067 : :
5068 : 0 : result = ConversionIsVisibleExt(oid, &is_missing);
5069 : :
5070 [ # # ]: 0 : if (is_missing)
5071 : 0 : PG_RETURN_NULL();
5072 : 0 : PG_RETURN_BOOL(result);
5073 : 0 : }
5074 : :
5075 : : Datum
5076 : 62 : pg_statistics_obj_is_visible(PG_FUNCTION_ARGS)
5077 : : {
5078 : 62 : Oid oid = PG_GETARG_OID(0);
5079 : 62 : bool result;
5080 : 62 : bool is_missing = false;
5081 : :
5082 : 62 : result = StatisticsObjIsVisibleExt(oid, &is_missing);
5083 : :
5084 [ + - ]: 62 : if (is_missing)
5085 : 0 : PG_RETURN_NULL();
5086 : 62 : PG_RETURN_BOOL(result);
5087 : 62 : }
5088 : :
5089 : : Datum
5090 : 0 : pg_ts_parser_is_visible(PG_FUNCTION_ARGS)
5091 : : {
5092 : 0 : Oid oid = PG_GETARG_OID(0);
5093 : 0 : bool result;
5094 : 0 : bool is_missing = false;
5095 : :
5096 : 0 : result = TSParserIsVisibleExt(oid, &is_missing);
5097 : :
5098 [ # # ]: 0 : if (is_missing)
5099 : 0 : PG_RETURN_NULL();
5100 : 0 : PG_RETURN_BOOL(result);
5101 : 0 : }
5102 : :
5103 : : Datum
5104 : 0 : pg_ts_dict_is_visible(PG_FUNCTION_ARGS)
5105 : : {
5106 : 0 : Oid oid = PG_GETARG_OID(0);
5107 : 0 : bool result;
5108 : 0 : bool is_missing = false;
5109 : :
5110 : 0 : result = TSDictionaryIsVisibleExt(oid, &is_missing);
5111 : :
5112 [ # # ]: 0 : if (is_missing)
5113 : 0 : PG_RETURN_NULL();
5114 : 0 : PG_RETURN_BOOL(result);
5115 : 0 : }
5116 : :
5117 : : Datum
5118 : 0 : pg_ts_template_is_visible(PG_FUNCTION_ARGS)
5119 : : {
5120 : 0 : Oid oid = PG_GETARG_OID(0);
5121 : 0 : bool result;
5122 : 0 : bool is_missing = false;
5123 : :
5124 : 0 : result = TSTemplateIsVisibleExt(oid, &is_missing);
5125 : :
5126 [ # # ]: 0 : if (is_missing)
5127 : 0 : PG_RETURN_NULL();
5128 : 0 : PG_RETURN_BOOL(result);
5129 : 0 : }
5130 : :
5131 : : Datum
5132 : 0 : pg_ts_config_is_visible(PG_FUNCTION_ARGS)
5133 : : {
5134 : 0 : Oid oid = PG_GETARG_OID(0);
5135 : 0 : bool result;
5136 : 0 : bool is_missing = false;
5137 : :
5138 : 0 : result = TSConfigIsVisibleExt(oid, &is_missing);
5139 : :
5140 [ # # ]: 0 : if (is_missing)
5141 : 0 : PG_RETURN_NULL();
5142 : 0 : PG_RETURN_BOOL(result);
5143 : 0 : }
5144 : :
5145 : : Datum
5146 : 343 : pg_my_temp_schema(PG_FUNCTION_ARGS)
5147 : : {
5148 : 343 : PG_RETURN_OID(myTempNamespace);
5149 : : }
5150 : :
5151 : : Datum
5152 : 4006 : pg_is_other_temp_schema(PG_FUNCTION_ARGS)
5153 : : {
5154 : 4006 : Oid oid = PG_GETARG_OID(0);
5155 : :
5156 : 8012 : PG_RETURN_BOOL(isOtherTempNamespace(oid));
5157 : 4006 : }
|
