PostgreSQL Source Code: src/backend/utils/fmgr/fmgr.c Source File

PostgreSQL Source Code git master
fmgr.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * fmgr.c
4 * The Postgres function manager.
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/utils/fmgr/fmgr.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16#include "postgres.h"
17
18#include "access/detoast.h"
19#include "access/htup_details.h"
20#include "catalog/pg_language.h"
21#include "catalog/pg_proc.h"
22#include "catalog/pg_type.h"
23#include "executor/functions.h"
24#include "lib/stringinfo.h"
25#include "miscadmin.h"
26#include "nodes/makefuncs.h"
27#include "nodes/miscnodes.h"
28#include "nodes/nodeFuncs.h"
29#include "pgstat.h"
30#include "utils/acl.h"
31#include "utils/builtins.h"
32#include "utils/fmgrtab.h"
33#include "utils/guc.h"
34#include "utils/lsyscache.h"
35#include "utils/syscache.h"
36
37/*
38 * Hooks for function calls
39 */
40 PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook = NULL;
41 PGDLLIMPORT fmgr_hook_type fmgr_hook = NULL;
42
43/*
44 * Hashtable for fast lookup of external C functions
45 */
46 typedef struct
47{
48 /* fn_oid is the hash key and so must be first! */
49 Oid fn_oid; /* OID of an external C function */
50 TransactionId fn_xmin; /* for checking up-to-dateness */
51 ItemPointerData fn_tid;
52 PGFunction user_fn; /* the function's address */
53 const Pg_finfo_record *inforec; /* address of its info record */
54} CFuncHashTabEntry;
55
56 static HTAB *CFuncHash = NULL;
57
58
59static void fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt,
60 bool ignore_security);
61static void fmgr_info_C_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple);
62static void fmgr_info_other_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple);
63static CFuncHashTabEntry *lookup_C_func(HeapTuple procedureTuple);
64static void record_C_func(HeapTuple procedureTuple,
65 PGFunction user_fn, const Pg_finfo_record *inforec);
66
67/* extern so it's callable via JIT */
68extern Datum fmgr_security_definer(PG_FUNCTION_ARGS);
69
70
71/*
72 * Lookup routines for builtin-function table. We can search by either Oid
73 * or name, but search by Oid is much faster.
74 */
75
76static const FmgrBuiltin *
77 fmgr_isbuiltin(Oid id)
78{
79 uint16 index;
80
81 /* fast lookup only possible if original oid still assigned */
82 if (id > fmgr_last_builtin_oid)
83 return NULL;
84
85 /*
86 * Lookup function data. If there's a miss in that range it's likely a
87 * nonexistent function, returning NULL here will trigger an ERROR later.
88 */
89 index = fmgr_builtin_oid_index[id];
90 if (index == InvalidOidBuiltinMapping)
91 return NULL;
92
93 return &fmgr_builtins[index];
94}
95
96/*
97 * Lookup a builtin by name. Note there can be more than one entry in
98 * the array with the same name, but they should all point to the same
99 * routine.
100 */
101static const FmgrBuiltin *
102 fmgr_lookupByName(const char *name)
103{
104 int i;
105
106 for (i = 0; i < fmgr_nbuiltins; i++)
107 {
108 if (strcmp(name, fmgr_builtins[i].funcName) == 0)
109 return fmgr_builtins + i;
110 }
111 return NULL;
112}
113
114/*
115 * This routine fills a FmgrInfo struct, given the OID
116 * of the function to be called.
117 *
118 * The caller's CurrentMemoryContext is used as the fn_mcxt of the info
119 * struct; this means that any subsidiary data attached to the info struct
120 * (either by fmgr_info itself, or later on by a function call handler)
121 * will be allocated in that context. The caller must ensure that this
122 * context is at least as long-lived as the info struct itself. This is
123 * not a problem in typical cases where the info struct is on the stack or
124 * in freshly-palloc'd space. However, if one intends to store an info
125 * struct in a long-lived table, it's better to use fmgr_info_cxt.
126 */
127void
128 fmgr_info(Oid functionId, FmgrInfo *finfo)
129{
130 fmgr_info_cxt_security(functionId, finfo, CurrentMemoryContext, false);
131}
132
133/*
134 * Fill a FmgrInfo struct, specifying a memory context in which its
135 * subsidiary data should go.
136 */
137void
138 fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
139{
140 fmgr_info_cxt_security(functionId, finfo, mcxt, false);
141}
142
143/*
144 * This one does the actual work. ignore_security is ordinarily false
145 * but is set to true when we need to avoid recursion.
146 */
147static void
148 fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt,
149 bool ignore_security)
150{
151 const FmgrBuiltin *fbp;
152 HeapTuple procedureTuple;
153 Form_pg_proc procedureStruct;
154 Datum prosrcdatum;
155 char *prosrc;
156
157 /*
158 * fn_oid *must* be filled in last. Some code assumes that if fn_oid is
159 * valid, the whole struct is valid. Some FmgrInfo struct's do survive
160 * elogs.
161 */
162 finfo->fn_oid = InvalidOid;
163 finfo->fn_extra = NULL;
164 finfo->fn_mcxt = mcxt;
165 finfo->fn_expr = NULL; /* caller may set this later */
166
167 if ((fbp = fmgr_isbuiltin(functionId)) != NULL)
168 {
169 /*
170 * Fast path for builtin functions: don't bother consulting pg_proc
171 */
172 finfo->fn_nargs = fbp->nargs;
173 finfo->fn_strict = fbp->strict;
174 finfo->fn_retset = fbp->retset;
175 finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
176 finfo->fn_addr = fbp->func;
177 finfo->fn_oid = functionId;
178 return;
179 }
180
181 /* Otherwise we need the pg_proc entry */
182 procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId));
183 if (!HeapTupleIsValid(procedureTuple))
184 elog(ERROR, "cache lookup failed for function %u", functionId);
185 procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
186
187 finfo->fn_nargs = procedureStruct->pronargs;
188 finfo->fn_strict = procedureStruct->proisstrict;
189 finfo->fn_retset = procedureStruct->proretset;
190
191 /*
192 * If it has prosecdef set, non-null proconfig, or if a plugin wants to
193 * hook function entry/exit, use fmgr_security_definer call handler ---
194 * unless we are being called again by fmgr_security_definer or
195 * fmgr_info_other_lang.
196 *
197 * When using fmgr_security_definer, function stats tracking is always
198 * disabled at the outer level, and instead we set the flag properly in
199 * fmgr_security_definer's private flinfo and implement the tracking
200 * inside fmgr_security_definer. This loses the ability to charge the
201 * overhead of fmgr_security_definer to the function, but gains the
202 * ability to set the track_functions GUC as a local GUC parameter of an
203 * interesting function and have the right things happen.
204 */
205 if (!ignore_security &&
206 (procedureStruct->prosecdef ||
207 !heap_attisnull(procedureTuple, Anum_pg_proc_proconfig, NULL) ||
208 FmgrHookIsNeeded(functionId)))
209 {
210 finfo->fn_addr = fmgr_security_definer;
211 finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
212 finfo->fn_oid = functionId;
213 ReleaseSysCache(procedureTuple);
214 return;
215 }
216
217 switch (procedureStruct->prolang)
218 {
219 case INTERNALlanguageId:
220
221 /*
222 * For an ordinary builtin function, we should never get here
223 * because the fmgr_isbuiltin() search above will have succeeded.
224 * However, if the user has done a CREATE FUNCTION to create an
225 * alias for a builtin function, we can end up here. In that case
226 * we have to look up the function by name. The name of the
227 * internal function is stored in prosrc (it doesn't have to be
228 * the same as the name of the alias!)
229 */
230 prosrcdatum = SysCacheGetAttrNotNull(PROCOID, procedureTuple,
231 Anum_pg_proc_prosrc);
232 prosrc = TextDatumGetCString(prosrcdatum);
233 fbp = fmgr_lookupByName(prosrc);
234 if (fbp == NULL)
235 ereport(ERROR,
236 (errcode(ERRCODE_UNDEFINED_FUNCTION),
237 errmsg("internal function \"%s\" is not in internal lookup table",
238 prosrc)));
239 pfree(prosrc);
240 /* Should we check that nargs, strict, retset match the table? */
241 finfo->fn_addr = fbp->func;
242 /* note this policy is also assumed in fast path above */
243 finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
244 break;
245
246 case ClanguageId:
247 fmgr_info_C_lang(functionId, finfo, procedureTuple);
248 finfo->fn_stats = TRACK_FUNC_PL; /* ie, track if ALL */
249 break;
250
251 case SQLlanguageId:
252 finfo->fn_addr = fmgr_sql;
253 finfo->fn_stats = TRACK_FUNC_PL; /* ie, track if ALL */
254 break;
255
256 default:
257 fmgr_info_other_lang(functionId, finfo, procedureTuple);
258 finfo->fn_stats = TRACK_FUNC_OFF; /* ie, track if not OFF */
259 break;
260 }
261
262 finfo->fn_oid = functionId;
263 ReleaseSysCache(procedureTuple);
264}
265
266/*
267 * Return module and C function name providing implementation of functionId.
268 *
269 * If *mod == NULL and *fn == NULL, no C symbol is known to implement
270 * function.
271 *
272 * If *mod == NULL and *fn != NULL, the function is implemented by a symbol in
273 * the main binary.
274 *
275 * If *mod != NULL and *fn != NULL the function is implemented in an extension
276 * shared object.
277 *
278 * The returned module and function names are pstrdup'ed into the current
279 * memory context.
280 */
281void
282 fmgr_symbol(Oid functionId, char **mod, char **fn)
283{
284 HeapTuple procedureTuple;
285 Form_pg_proc procedureStruct;
286 Datum prosrcattr;
287 Datum probinattr;
288
289 procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionId));
290 if (!HeapTupleIsValid(procedureTuple))
291 elog(ERROR, "cache lookup failed for function %u", functionId);
292 procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
293
294 if (procedureStruct->prosecdef ||
295 !heap_attisnull(procedureTuple, Anum_pg_proc_proconfig, NULL) ||
296 FmgrHookIsNeeded(functionId))
297 {
298 *mod = NULL; /* core binary */
299 *fn = pstrdup("fmgr_security_definer");
300 ReleaseSysCache(procedureTuple);
301 return;
302 }
303
304 /* see fmgr_info_cxt_security for the individual cases */
305 switch (procedureStruct->prolang)
306 {
307 case INTERNALlanguageId:
308 prosrcattr = SysCacheGetAttrNotNull(PROCOID, procedureTuple,
309 Anum_pg_proc_prosrc);
310
311 *mod = NULL; /* core binary */
312 *fn = TextDatumGetCString(prosrcattr);
313 break;
314
315 case ClanguageId:
316 prosrcattr = SysCacheGetAttrNotNull(PROCOID, procedureTuple,
317 Anum_pg_proc_prosrc);
318
319 probinattr = SysCacheGetAttrNotNull(PROCOID, procedureTuple,
320 Anum_pg_proc_probin);
321
322 /*
323 * No need to check symbol presence / API version here, already
324 * checked in fmgr_info_cxt_security.
325 */
326 *mod = TextDatumGetCString(probinattr);
327 *fn = TextDatumGetCString(prosrcattr);
328 break;
329
330 case SQLlanguageId:
331 *mod = NULL; /* core binary */
332 *fn = pstrdup("fmgr_sql");
333 break;
334
335 default:
336 *mod = NULL;
337 *fn = NULL; /* unknown, pass pointer */
338 break;
339 }
340
341 ReleaseSysCache(procedureTuple);
342}
343
344
345/*
346 * Special fmgr_info processing for C-language functions. Note that
347 * finfo->fn_oid is not valid yet.
348 */
349static void
350 fmgr_info_C_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple)
351{
352 CFuncHashTabEntry *hashentry;
353 PGFunction user_fn;
354 const Pg_finfo_record *inforec;
355
356 /*
357 * See if we have the function address cached already
358 */
359 hashentry = lookup_C_func(procedureTuple);
360 if (hashentry)
361 {
362 user_fn = hashentry->user_fn;
363 inforec = hashentry->inforec;
364 }
365 else
366 {
367 Datum prosrcattr,
368 probinattr;
369 char *prosrcstring,
370 *probinstring;
371 void *libraryhandle;
372
373 /*
374 * Get prosrc and probin strings (link symbol and library filename).
375 * While in general these columns might be null, that's not allowed
376 * for C-language functions.
377 */
378 prosrcattr = SysCacheGetAttrNotNull(PROCOID, procedureTuple,
379 Anum_pg_proc_prosrc);
380 prosrcstring = TextDatumGetCString(prosrcattr);
381
382 probinattr = SysCacheGetAttrNotNull(PROCOID, procedureTuple,
383 Anum_pg_proc_probin);
384 probinstring = TextDatumGetCString(probinattr);
385
386 /* Look up the function itself */
387 user_fn = load_external_function(probinstring, prosrcstring, true,
388 &libraryhandle);
389
390 /* Get the function information record (real or default) */
391 inforec = fetch_finfo_record(libraryhandle, prosrcstring);
392
393 /* Cache the addresses for later calls */
394 record_C_func(procedureTuple, user_fn, inforec);
395
396 pfree(prosrcstring);
397 pfree(probinstring);
398 }
399
400 switch (inforec->api_version)
401 {
402 case 1:
403 /* New style: call directly */
404 finfo->fn_addr = user_fn;
405 break;
406 default:
407 /* Shouldn't get here if fetch_finfo_record did its job */
408 elog(ERROR, "unrecognized function API version: %d",
409 inforec->api_version);
410 break;
411 }
412}
413
414/*
415 * Special fmgr_info processing for other-language functions. Note
416 * that finfo->fn_oid is not valid yet.
417 */
418static void
419 fmgr_info_other_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple)
420{
421 Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
422 Oid language = procedureStruct->prolang;
423 HeapTuple languageTuple;
424 Form_pg_language languageStruct;
425 FmgrInfo plfinfo;
426
427 languageTuple = SearchSysCache1(LANGOID, ObjectIdGetDatum(language));
428 if (!HeapTupleIsValid(languageTuple))
429 elog(ERROR, "cache lookup failed for language %u", language);
430 languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
431
432 /*
433 * Look up the language's call handler function, ignoring any attributes
434 * that would normally cause insertion of fmgr_security_definer. We need
435 * to get back a bare pointer to the actual C-language function.
436 */
437 fmgr_info_cxt_security(languageStruct->lanplcallfoid, &plfinfo,
438 CurrentMemoryContext, true);
439 finfo->fn_addr = plfinfo.fn_addr;
440
441 ReleaseSysCache(languageTuple);
442}
443
444/*
445 * Fetch and validate the information record for the given external function.
446 * The function is specified by a handle for the containing library
447 * (obtained from load_external_function) as well as the function name.
448 *
449 * If no info function exists for the given name an error is raised.
450 *
451 * This function is broken out of fmgr_info_C_lang so that fmgr_c_validator
452 * can validate the information record for a function not yet entered into
453 * pg_proc.
454 */
455const Pg_finfo_record *
456 fetch_finfo_record(void *filehandle, const char *funcname)
457{
458 char *infofuncname;
459 PGFInfoFunction infofunc;
460 const Pg_finfo_record *inforec;
461
462 infofuncname = psprintf("pg_finfo_%s", funcname);
463
464 /* Try to look up the info function */
465 infofunc = (PGFInfoFunction) lookup_external_function(filehandle,
466 infofuncname);
467 if (infofunc == NULL)
468 {
469 ereport(ERROR,
470 (errcode(ERRCODE_UNDEFINED_FUNCTION),
471 errmsg("could not find function information for function \"%s\"",
472 funcname),
473 errhint("SQL-callable functions need an accompanying PG_FUNCTION_INFO_V1(funcname).")));
474 return NULL; /* silence compiler */
475 }
476
477 /* Found, so call it */
478 inforec = (*infofunc) ();
479
480 /* Validate result as best we can */
481 if (inforec == NULL)
482 elog(ERROR, "null result from info function \"%s\"", infofuncname);
483 switch (inforec->api_version)
484 {
485 case 1:
486 /* OK, no additional fields to validate */
487 break;
488 default:
489 ereport(ERROR,
490 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
491 errmsg("unrecognized API version %d reported by info function \"%s\"",
492 inforec->api_version, infofuncname)));
493 break;
494 }
495
496 pfree(infofuncname);
497 return inforec;
498}
499
500
501/*-------------------------------------------------------------------------
502 * Routines for caching lookup information for external C functions.
503 *
504 * The routines in dfmgr.c are relatively slow, so we try to avoid running
505 * them more than once per external function per session. We use a hash table
506 * with the function OID as the lookup key.
507 *-------------------------------------------------------------------------
508 */
509
510/*
511 * lookup_C_func: try to find a C function in the hash table
512 *
513 * If an entry exists and is up to date, return it; else return NULL
514 */
515static CFuncHashTabEntry *
516 lookup_C_func(HeapTuple procedureTuple)
517{
518 Oid fn_oid = ((Form_pg_proc) GETSTRUCT(procedureTuple))->oid;
519 CFuncHashTabEntry *entry;
520
521 if (CFuncHash == NULL)
522 return NULL; /* no table yet */
523 entry = (CFuncHashTabEntry *)
524 hash_search(CFuncHash,
525 &fn_oid,
526 HASH_FIND,
527 NULL);
528 if (entry == NULL)
529 return NULL; /* no such entry */
530 if (entry->fn_xmin == HeapTupleHeaderGetRawXmin(procedureTuple->t_data) &&
531 ItemPointerEquals(&entry->fn_tid, &procedureTuple->t_self))
532 return entry; /* OK */
533 return NULL; /* entry is out of date */
534}
535
536/*
537 * record_C_func: enter (or update) info about a C function in the hash table
538 */
539static void
540 record_C_func(HeapTuple procedureTuple,
541 PGFunction user_fn, const Pg_finfo_record *inforec)
542{
543 Oid fn_oid = ((Form_pg_proc) GETSTRUCT(procedureTuple))->oid;
544 CFuncHashTabEntry *entry;
545 bool found;
546
547 /* Create the hash table if it doesn't exist yet */
548 if (CFuncHash == NULL)
549 {
550 HASHCTL hash_ctl;
551
552 hash_ctl.keysize = sizeof(Oid);
553 hash_ctl.entrysize = sizeof(CFuncHashTabEntry);
554 CFuncHash = hash_create("CFuncHash",
555 100,
556 &hash_ctl,
557 HASH_ELEM | HASH_BLOBS);
558 }
559
560 entry = (CFuncHashTabEntry *)
561 hash_search(CFuncHash,
562 &fn_oid,
563 HASH_ENTER,
564 &found);
565 /* OID is already filled in */
566 entry->fn_xmin = HeapTupleHeaderGetRawXmin(procedureTuple->t_data);
567 entry->fn_tid = procedureTuple->t_self;
568 entry->user_fn = user_fn;
569 entry->inforec = inforec;
570}
571
572
573/*
574 * Copy an FmgrInfo struct
575 *
576 * This is inherently somewhat bogus since we can't reliably duplicate
577 * language-dependent subsidiary info. We cheat by zeroing fn_extra,
578 * instead, meaning that subsidiary info will have to be recomputed.
579 */
580void
581 fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo,
582 MemoryContext destcxt)
583{
584 memcpy(dstinfo, srcinfo, sizeof(FmgrInfo));
585 dstinfo->fn_mcxt = destcxt;
586 dstinfo->fn_extra = NULL;
587}
588
589
590/*
591 * Specialized lookup routine for fmgr_internal_validator: given the alleged
592 * name of an internal function, return the OID of the function.
593 * If the name is not recognized, return InvalidOid.
594 */
595Oid
596 fmgr_internal_function(const char *proname)
597{
598 const FmgrBuiltin *fbp = fmgr_lookupByName(proname);
599
600 if (fbp == NULL)
601 return InvalidOid;
602 return fbp->foid;
603}
604
605
606/*
607 * Support for security-definer and proconfig-using functions. We support
608 * both of these features using the same call handler, because they are
609 * often used together and it would be inefficient (as well as notationally
610 * messy) to have two levels of call handler involved.
611 */
612 struct fmgr_security_definer_cache
613{
614 FmgrInfo flinfo; /* lookup info for target function */
615 Oid userid; /* userid to set, or InvalidOid */
616 List *configNames; /* GUC names to set, or NIL */
617 List *configHandles; /* GUC handles to set, or NIL */
618 List *configValues; /* GUC values to set, or NIL */
619 Datum arg; /* passthrough argument for plugin modules */
620};
621
622/*
623 * Function handler for security-definer/proconfig/plugin-hooked functions.
624 * We extract the OID of the actual function and do a fmgr lookup again.
625 * Then we fetch the pg_proc row and copy the owner ID and proconfig fields.
626 * (All this info is cached for the duration of the current query.)
627 * To execute a call, we temporarily replace the flinfo with the cached
628 * and looked-up one, while keeping the outer fcinfo (which contains all
629 * the actual arguments, etc.) intact. This is not re-entrant, but then
630 * the fcinfo itself can't be used reentrantly anyway.
631 */
632extern Datum
633 fmgr_security_definer(PG_FUNCTION_ARGS)
634{
635 Datum result;
636 struct fmgr_security_definer_cache *volatile fcache;
637 FmgrInfo *save_flinfo;
638 Oid save_userid;
639 int save_sec_context;
640 ListCell *lc1,
641 *lc2,
642 *lc3;
643 int save_nestlevel;
644 PgStat_FunctionCallUsage fcusage;
645
646 if (!fcinfo->flinfo->fn_extra)
647 {
648 HeapTuple tuple;
649 Form_pg_proc procedureStruct;
650 Datum datum;
651 bool isnull;
652 MemoryContext oldcxt;
653
654 fcache = MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
655 sizeof(*fcache));
656
657 fmgr_info_cxt_security(fcinfo->flinfo->fn_oid, &fcache->flinfo,
658 fcinfo->flinfo->fn_mcxt, true);
659 fcache->flinfo.fn_expr = fcinfo->flinfo->fn_expr;
660
661 tuple = SearchSysCache1(PROCOID,
662 ObjectIdGetDatum(fcinfo->flinfo->fn_oid));
663 if (!HeapTupleIsValid(tuple))
664 elog(ERROR, "cache lookup failed for function %u",
665 fcinfo->flinfo->fn_oid);
666 procedureStruct = (Form_pg_proc) GETSTRUCT(tuple);
667
668 if (procedureStruct->prosecdef)
669 fcache->userid = procedureStruct->proowner;
670
671 datum = SysCacheGetAttr(PROCOID, tuple, Anum_pg_proc_proconfig,
672 &isnull);
673 if (!isnull)
674 {
675 ArrayType *array;
676 ListCell *lc;
677
678 oldcxt = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
679 array = DatumGetArrayTypeP(datum);
680 TransformGUCArray(array, &fcache->configNames,
681 &fcache->configValues);
682
683 /* transform names to config handles to avoid lookup cost */
684 fcache->configHandles = NIL;
685 foreach(lc, fcache->configNames)
686 {
687 char *name = (char *) lfirst(lc);
688
689 fcache->configHandles = lappend(fcache->configHandles,
690 get_config_handle(name));
691 }
692
693 MemoryContextSwitchTo(oldcxt);
694 }
695
696 ReleaseSysCache(tuple);
697
698 fcinfo->flinfo->fn_extra = fcache;
699 }
700 else
701 fcache = fcinfo->flinfo->fn_extra;
702
703 /* GetUserIdAndSecContext is cheap enough that no harm in a wasted call */
704 GetUserIdAndSecContext(&save_userid, &save_sec_context);
705 if (fcache->configNames != NIL) /* Need a new GUC nesting level */
706 save_nestlevel = NewGUCNestLevel();
707 else
708 save_nestlevel = 0; /* keep compiler quiet */
709
710 if (OidIsValid(fcache->userid))
711 SetUserIdAndSecContext(fcache->userid,
712 save_sec_context | SECURITY_LOCAL_USERID_CHANGE);
713
714 forthree(lc1, fcache->configNames,
715 lc2, fcache->configHandles,
716 lc3, fcache->configValues)
717 {
718 GucContext context = superuser() ? PGC_SUSET : PGC_USERSET;
719 GucSource source = PGC_S_SESSION;
720 GucAction action = GUC_ACTION_SAVE;
721 char *name = lfirst(lc1);
722 config_handle *handle = lfirst(lc2);
723 char *value = lfirst(lc3);
724
725 (void) set_config_with_handle(name, handle, value,
726 context, source, GetUserId(),
727 action, true, 0, false);
728 }
729
730 /* function manager hook */
731 if (fmgr_hook)
732 (*fmgr_hook) (FHET_START, &fcache->flinfo, &fcache->arg);
733
734 /*
735 * We don't need to restore GUC or userid settings on error, because the
736 * ensuing xact or subxact abort will do that. The PG_TRY block is only
737 * needed to clean up the flinfo link.
738 */
739 save_flinfo = fcinfo->flinfo;
740
741 PG_TRY();
742 {
743 fcinfo->flinfo = &fcache->flinfo;
744
745 /* See notes in fmgr_info_cxt_security */
746 pgstat_init_function_usage(fcinfo, &fcusage);
747
748 result = FunctionCallInvoke(fcinfo);
749
750 /*
751 * We could be calling either a regular or a set-returning function,
752 * so we have to test to see what finalize flag to use.
753 */
754 pgstat_end_function_usage(&fcusage,
755 (fcinfo->resultinfo == NULL ||
756 !IsA(fcinfo->resultinfo, ReturnSetInfo) ||
757 ((ReturnSetInfo *) fcinfo->resultinfo)->isDone != ExprMultipleResult));
758 }
759 PG_CATCH();
760 {
761 fcinfo->flinfo = save_flinfo;
762 if (fmgr_hook)
763 (*fmgr_hook) (FHET_ABORT, &fcache->flinfo, &fcache->arg);
764 PG_RE_THROW();
765 }
766 PG_END_TRY();
767
768 fcinfo->flinfo = save_flinfo;
769
770 if (fcache->configNames != NIL)
771 AtEOXact_GUC(true, save_nestlevel);
772 if (OidIsValid(fcache->userid))
773 SetUserIdAndSecContext(save_userid, save_sec_context);
774 if (fmgr_hook)
775 (*fmgr_hook) (FHET_END, &fcache->flinfo, &fcache->arg);
776
777 return result;
778}
779
780
781/*-------------------------------------------------------------------------
782 * Support routines for callers of fmgr-compatible functions
783 *-------------------------------------------------------------------------
784 */
785
786/*
787 * These are for invocation of a specifically named function with a
788 * directly-computed parameter list. Note that neither arguments nor result
789 * are allowed to be NULL. Also, the function cannot be one that needs to
790 * look at FmgrInfo, since there won't be any.
791 */
792Datum
793 DirectFunctionCall1Coll(PGFunction func, Oid collation, Datum arg1)
794{
795 LOCAL_FCINFO(fcinfo, 1);
796 Datum result;
797
798 InitFunctionCallInfoData(*fcinfo, NULL, 1, collation, NULL, NULL);
799
800 fcinfo->args[0].value = arg1;
801 fcinfo->args[0].isnull = false;
802
803 result = (*func) (fcinfo);
804
805 /* Check for null result, since caller is clearly not expecting one */
806 if (fcinfo->isnull)
807 elog(ERROR, "function %p returned NULL", (void *) func);
808
809 return result;
810}
811
812Datum
813 DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2)
814{
815 LOCAL_FCINFO(fcinfo, 2);
816 Datum result;
817
818 InitFunctionCallInfoData(*fcinfo, NULL, 2, collation, NULL, NULL);
819
820 fcinfo->args[0].value = arg1;
821 fcinfo->args[0].isnull = false;
822 fcinfo->args[1].value = arg2;
823 fcinfo->args[1].isnull = false;
824
825 result = (*func) (fcinfo);
826
827 /* Check for null result, since caller is clearly not expecting one */
828 if (fcinfo->isnull)
829 elog(ERROR, "function %p returned NULL", (void *) func);
830
831 return result;
832}
833
834Datum
835 DirectFunctionCall3Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
836 Datum arg3)
837{
838 LOCAL_FCINFO(fcinfo, 3);
839 Datum result;
840
841 InitFunctionCallInfoData(*fcinfo, NULL, 3, collation, NULL, NULL);
842
843 fcinfo->args[0].value = arg1;
844 fcinfo->args[0].isnull = false;
845 fcinfo->args[1].value = arg2;
846 fcinfo->args[1].isnull = false;
847 fcinfo->args[2].value = arg3;
848 fcinfo->args[2].isnull = false;
849
850 result = (*func) (fcinfo);
851
852 /* Check for null result, since caller is clearly not expecting one */
853 if (fcinfo->isnull)
854 elog(ERROR, "function %p returned NULL", (void *) func);
855
856 return result;
857}
858
859Datum
860 DirectFunctionCall4Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
861 Datum arg3, Datum arg4)
862{
863 LOCAL_FCINFO(fcinfo, 4);
864 Datum result;
865
866 InitFunctionCallInfoData(*fcinfo, NULL, 4, collation, NULL, NULL);
867
868 fcinfo->args[0].value = arg1;
869 fcinfo->args[0].isnull = false;
870 fcinfo->args[1].value = arg2;
871 fcinfo->args[1].isnull = false;
872 fcinfo->args[2].value = arg3;
873 fcinfo->args[2].isnull = false;
874 fcinfo->args[3].value = arg4;
875 fcinfo->args[3].isnull = false;
876
877 result = (*func) (fcinfo);
878
879 /* Check for null result, since caller is clearly not expecting one */
880 if (fcinfo->isnull)
881 elog(ERROR, "function %p returned NULL", (void *) func);
882
883 return result;
884}
885
886Datum
887 DirectFunctionCall5Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
888 Datum arg3, Datum arg4, Datum arg5)
889{
890 LOCAL_FCINFO(fcinfo, 5);
891 Datum result;
892
893 InitFunctionCallInfoData(*fcinfo, NULL, 5, collation, NULL, NULL);
894
895 fcinfo->args[0].value = arg1;
896 fcinfo->args[0].isnull = false;
897 fcinfo->args[1].value = arg2;
898 fcinfo->args[1].isnull = false;
899 fcinfo->args[2].value = arg3;
900 fcinfo->args[2].isnull = false;
901 fcinfo->args[3].value = arg4;
902 fcinfo->args[3].isnull = false;
903 fcinfo->args[4].value = arg5;
904 fcinfo->args[4].isnull = false;
905
906 result = (*func) (fcinfo);
907
908 /* Check for null result, since caller is clearly not expecting one */
909 if (fcinfo->isnull)
910 elog(ERROR, "function %p returned NULL", (void *) func);
911
912 return result;
913}
914
915Datum
916 DirectFunctionCall6Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
917 Datum arg3, Datum arg4, Datum arg5,
918 Datum arg6)
919{
920 LOCAL_FCINFO(fcinfo, 6);
921 Datum result;
922
923 InitFunctionCallInfoData(*fcinfo, NULL, 6, collation, NULL, NULL);
924
925 fcinfo->args[0].value = arg1;
926 fcinfo->args[0].isnull = false;
927 fcinfo->args[1].value = arg2;
928 fcinfo->args[1].isnull = false;
929 fcinfo->args[2].value = arg3;
930 fcinfo->args[2].isnull = false;
931 fcinfo->args[3].value = arg4;
932 fcinfo->args[3].isnull = false;
933 fcinfo->args[4].value = arg5;
934 fcinfo->args[4].isnull = false;
935 fcinfo->args[5].value = arg6;
936 fcinfo->args[5].isnull = false;
937
938 result = (*func) (fcinfo);
939
940 /* Check for null result, since caller is clearly not expecting one */
941 if (fcinfo->isnull)
942 elog(ERROR, "function %p returned NULL", (void *) func);
943
944 return result;
945}
946
947Datum
948 DirectFunctionCall7Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
949 Datum arg3, Datum arg4, Datum arg5,
950 Datum arg6, Datum arg7)
951{
952 LOCAL_FCINFO(fcinfo, 7);
953 Datum result;
954
955 InitFunctionCallInfoData(*fcinfo, NULL, 7, collation, NULL, NULL);
956
957 fcinfo->args[0].value = arg1;
958 fcinfo->args[0].isnull = false;
959 fcinfo->args[1].value = arg2;
960 fcinfo->args[1].isnull = false;
961 fcinfo->args[2].value = arg3;
962 fcinfo->args[2].isnull = false;
963 fcinfo->args[3].value = arg4;
964 fcinfo->args[3].isnull = false;
965 fcinfo->args[4].value = arg5;
966 fcinfo->args[4].isnull = false;
967 fcinfo->args[5].value = arg6;
968 fcinfo->args[5].isnull = false;
969 fcinfo->args[6].value = arg7;
970 fcinfo->args[6].isnull = false;
971
972 result = (*func) (fcinfo);
973
974 /* Check for null result, since caller is clearly not expecting one */
975 if (fcinfo->isnull)
976 elog(ERROR, "function %p returned NULL", (void *) func);
977
978 return result;
979}
980
981Datum
982 DirectFunctionCall8Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
983 Datum arg3, Datum arg4, Datum arg5,
984 Datum arg6, Datum arg7, Datum arg8)
985{
986 LOCAL_FCINFO(fcinfo, 8);
987 Datum result;
988
989 InitFunctionCallInfoData(*fcinfo, NULL, 8, collation, NULL, NULL);
990
991 fcinfo->args[0].value = arg1;
992 fcinfo->args[0].isnull = false;
993 fcinfo->args[1].value = arg2;
994 fcinfo->args[1].isnull = false;
995 fcinfo->args[2].value = arg3;
996 fcinfo->args[2].isnull = false;
997 fcinfo->args[3].value = arg4;
998 fcinfo->args[3].isnull = false;
999 fcinfo->args[4].value = arg5;
1000 fcinfo->args[4].isnull = false;
1001 fcinfo->args[5].value = arg6;
1002 fcinfo->args[5].isnull = false;
1003 fcinfo->args[6].value = arg7;
1004 fcinfo->args[6].isnull = false;
1005 fcinfo->args[7].value = arg8;
1006 fcinfo->args[7].isnull = false;
1007
1008 result = (*func) (fcinfo);
1009
1010 /* Check for null result, since caller is clearly not expecting one */
1011 if (fcinfo->isnull)
1012 elog(ERROR, "function %p returned NULL", (void *) func);
1013
1014 return result;
1015}
1016
1017Datum
1018 DirectFunctionCall9Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2,
1019 Datum arg3, Datum arg4, Datum arg5,
1020 Datum arg6, Datum arg7, Datum arg8,
1021 Datum arg9)
1022{
1023 LOCAL_FCINFO(fcinfo, 9);
1024 Datum result;
1025
1026 InitFunctionCallInfoData(*fcinfo, NULL, 9, collation, NULL, NULL);
1027
1028 fcinfo->args[0].value = arg1;
1029 fcinfo->args[0].isnull = false;
1030 fcinfo->args[1].value = arg2;
1031 fcinfo->args[1].isnull = false;
1032 fcinfo->args[2].value = arg3;
1033 fcinfo->args[2].isnull = false;
1034 fcinfo->args[3].value = arg4;
1035 fcinfo->args[3].isnull = false;
1036 fcinfo->args[4].value = arg5;
1037 fcinfo->args[4].isnull = false;
1038 fcinfo->args[5].value = arg6;
1039 fcinfo->args[5].isnull = false;
1040 fcinfo->args[6].value = arg7;
1041 fcinfo->args[6].isnull = false;
1042 fcinfo->args[7].value = arg8;
1043 fcinfo->args[7].isnull = false;
1044 fcinfo->args[8].value = arg9;
1045 fcinfo->args[8].isnull = false;
1046
1047 result = (*func) (fcinfo);
1048
1049 /* Check for null result, since caller is clearly not expecting one */
1050 if (fcinfo->isnull)
1051 elog(ERROR, "function %p returned NULL", (void *) func);
1052
1053 return result;
1054}
1055
1056/*
1057 * These functions work like the DirectFunctionCall functions except that
1058 * they use the flinfo parameter to initialise the fcinfo for the call.
1059 * It's recommended that the callee only use the fn_extra and fn_mcxt
1060 * fields, as other fields will typically describe the calling function
1061 * not the callee. Conversely, the calling function should not have
1062 * used fn_extra, unless its use is known to be compatible with the callee's.
1063 */
1064
1065Datum
1066 CallerFInfoFunctionCall1(PGFunction func, FmgrInfo *flinfo, Oid collation, Datum arg1)
1067{
1068 LOCAL_FCINFO(fcinfo, 1);
1069 Datum result;
1070
1071 InitFunctionCallInfoData(*fcinfo, flinfo, 1, collation, NULL, NULL);
1072
1073 fcinfo->args[0].value = arg1;
1074 fcinfo->args[0].isnull = false;
1075
1076 result = (*func) (fcinfo);
1077
1078 /* Check for null result, since caller is clearly not expecting one */
1079 if (fcinfo->isnull)
1080 elog(ERROR, "function %p returned NULL", (void *) func);
1081
1082 return result;
1083}
1084
1085Datum
1086 CallerFInfoFunctionCall2(PGFunction func, FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
1087{
1088 LOCAL_FCINFO(fcinfo, 2);
1089 Datum result;
1090
1091 InitFunctionCallInfoData(*fcinfo, flinfo, 2, collation, NULL, NULL);
1092
1093 fcinfo->args[0].value = arg1;
1094 fcinfo->args[0].isnull = false;
1095 fcinfo->args[1].value = arg2;
1096 fcinfo->args[1].isnull = false;
1097
1098 result = (*func) (fcinfo);
1099
1100 /* Check for null result, since caller is clearly not expecting one */
1101 if (fcinfo->isnull)
1102 elog(ERROR, "function %p returned NULL", (void *) func);
1103
1104 return result;
1105}
1106
1107/*
1108 * These are for invocation of a previously-looked-up function with a
1109 * directly-computed parameter list. Note that neither arguments nor result
1110 * are allowed to be NULL.
1111 */
1112Datum
1113 FunctionCall0Coll(FmgrInfo *flinfo, Oid collation)
1114{
1115 LOCAL_FCINFO(fcinfo, 0);
1116 Datum result;
1117
1118 InitFunctionCallInfoData(*fcinfo, flinfo, 0, collation, NULL, NULL);
1119
1120 result = FunctionCallInvoke(fcinfo);
1121
1122 /* Check for null result, since caller is clearly not expecting one */
1123 if (fcinfo->isnull)
1124 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1125
1126 return result;
1127}
1128
1129Datum
1130 FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, Datum arg1)
1131{
1132 LOCAL_FCINFO(fcinfo, 1);
1133 Datum result;
1134
1135 InitFunctionCallInfoData(*fcinfo, flinfo, 1, collation, NULL, NULL);
1136
1137 fcinfo->args[0].value = arg1;
1138 fcinfo->args[0].isnull = false;
1139
1140 result = FunctionCallInvoke(fcinfo);
1141
1142 /* Check for null result, since caller is clearly not expecting one */
1143 if (fcinfo->isnull)
1144 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1145
1146 return result;
1147}
1148
1149Datum
1150 FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
1151{
1152 LOCAL_FCINFO(fcinfo, 2);
1153 Datum result;
1154
1155 InitFunctionCallInfoData(*fcinfo, flinfo, 2, collation, NULL, NULL);
1156
1157 fcinfo->args[0].value = arg1;
1158 fcinfo->args[0].isnull = false;
1159 fcinfo->args[1].value = arg2;
1160 fcinfo->args[1].isnull = false;
1161
1162 result = FunctionCallInvoke(fcinfo);
1163
1164 /* Check for null result, since caller is clearly not expecting one */
1165 if (fcinfo->isnull)
1166 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1167
1168 return result;
1169}
1170
1171Datum
1172 FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1173 Datum arg3)
1174{
1175 LOCAL_FCINFO(fcinfo, 3);
1176 Datum result;
1177
1178 InitFunctionCallInfoData(*fcinfo, flinfo, 3, collation, NULL, NULL);
1179
1180 fcinfo->args[0].value = arg1;
1181 fcinfo->args[0].isnull = false;
1182 fcinfo->args[1].value = arg2;
1183 fcinfo->args[1].isnull = false;
1184 fcinfo->args[2].value = arg3;
1185 fcinfo->args[2].isnull = false;
1186
1187 result = FunctionCallInvoke(fcinfo);
1188
1189 /* Check for null result, since caller is clearly not expecting one */
1190 if (fcinfo->isnull)
1191 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1192
1193 return result;
1194}
1195
1196Datum
1197 FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1198 Datum arg3, Datum arg4)
1199{
1200 LOCAL_FCINFO(fcinfo, 4);
1201 Datum result;
1202
1203 InitFunctionCallInfoData(*fcinfo, flinfo, 4, collation, NULL, NULL);
1204
1205 fcinfo->args[0].value = arg1;
1206 fcinfo->args[0].isnull = false;
1207 fcinfo->args[1].value = arg2;
1208 fcinfo->args[1].isnull = false;
1209 fcinfo->args[2].value = arg3;
1210 fcinfo->args[2].isnull = false;
1211 fcinfo->args[3].value = arg4;
1212 fcinfo->args[3].isnull = false;
1213
1214 result = FunctionCallInvoke(fcinfo);
1215
1216 /* Check for null result, since caller is clearly not expecting one */
1217 if (fcinfo->isnull)
1218 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1219
1220 return result;
1221}
1222
1223Datum
1224 FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1225 Datum arg3, Datum arg4, Datum arg5)
1226{
1227 LOCAL_FCINFO(fcinfo, 5);
1228 Datum result;
1229
1230 InitFunctionCallInfoData(*fcinfo, flinfo, 5, collation, NULL, NULL);
1231
1232 fcinfo->args[0].value = arg1;
1233 fcinfo->args[0].isnull = false;
1234 fcinfo->args[1].value = arg2;
1235 fcinfo->args[1].isnull = false;
1236 fcinfo->args[2].value = arg3;
1237 fcinfo->args[2].isnull = false;
1238 fcinfo->args[3].value = arg4;
1239 fcinfo->args[3].isnull = false;
1240 fcinfo->args[4].value = arg5;
1241 fcinfo->args[4].isnull = false;
1242
1243 result = FunctionCallInvoke(fcinfo);
1244
1245 /* Check for null result, since caller is clearly not expecting one */
1246 if (fcinfo->isnull)
1247 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1248
1249 return result;
1250}
1251
1252Datum
1253 FunctionCall6Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1254 Datum arg3, Datum arg4, Datum arg5,
1255 Datum arg6)
1256{
1257 LOCAL_FCINFO(fcinfo, 6);
1258 Datum result;
1259
1260 InitFunctionCallInfoData(*fcinfo, flinfo, 6, collation, NULL, NULL);
1261
1262 fcinfo->args[0].value = arg1;
1263 fcinfo->args[0].isnull = false;
1264 fcinfo->args[1].value = arg2;
1265 fcinfo->args[1].isnull = false;
1266 fcinfo->args[2].value = arg3;
1267 fcinfo->args[2].isnull = false;
1268 fcinfo->args[3].value = arg4;
1269 fcinfo->args[3].isnull = false;
1270 fcinfo->args[4].value = arg5;
1271 fcinfo->args[4].isnull = false;
1272 fcinfo->args[5].value = arg6;
1273 fcinfo->args[5].isnull = false;
1274
1275 result = FunctionCallInvoke(fcinfo);
1276
1277 /* Check for null result, since caller is clearly not expecting one */
1278 if (fcinfo->isnull)
1279 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1280
1281 return result;
1282}
1283
1284Datum
1285 FunctionCall7Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1286 Datum arg3, Datum arg4, Datum arg5,
1287 Datum arg6, Datum arg7)
1288{
1289 LOCAL_FCINFO(fcinfo, 7);
1290 Datum result;
1291
1292 InitFunctionCallInfoData(*fcinfo, flinfo, 7, collation, NULL, NULL);
1293
1294 fcinfo->args[0].value = arg1;
1295 fcinfo->args[0].isnull = false;
1296 fcinfo->args[1].value = arg2;
1297 fcinfo->args[1].isnull = false;
1298 fcinfo->args[2].value = arg3;
1299 fcinfo->args[2].isnull = false;
1300 fcinfo->args[3].value = arg4;
1301 fcinfo->args[3].isnull = false;
1302 fcinfo->args[4].value = arg5;
1303 fcinfo->args[4].isnull = false;
1304 fcinfo->args[5].value = arg6;
1305 fcinfo->args[5].isnull = false;
1306 fcinfo->args[6].value = arg7;
1307 fcinfo->args[6].isnull = false;
1308
1309 result = FunctionCallInvoke(fcinfo);
1310
1311 /* Check for null result, since caller is clearly not expecting one */
1312 if (fcinfo->isnull)
1313 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1314
1315 return result;
1316}
1317
1318Datum
1319 FunctionCall8Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1320 Datum arg3, Datum arg4, Datum arg5,
1321 Datum arg6, Datum arg7, Datum arg8)
1322{
1323 LOCAL_FCINFO(fcinfo, 8);
1324 Datum result;
1325
1326 InitFunctionCallInfoData(*fcinfo, flinfo, 8, collation, NULL, NULL);
1327
1328 fcinfo->args[0].value = arg1;
1329 fcinfo->args[0].isnull = false;
1330 fcinfo->args[1].value = arg2;
1331 fcinfo->args[1].isnull = false;
1332 fcinfo->args[2].value = arg3;
1333 fcinfo->args[2].isnull = false;
1334 fcinfo->args[3].value = arg4;
1335 fcinfo->args[3].isnull = false;
1336 fcinfo->args[4].value = arg5;
1337 fcinfo->args[4].isnull = false;
1338 fcinfo->args[5].value = arg6;
1339 fcinfo->args[5].isnull = false;
1340 fcinfo->args[6].value = arg7;
1341 fcinfo->args[6].isnull = false;
1342 fcinfo->args[7].value = arg8;
1343 fcinfo->args[7].isnull = false;
1344
1345 result = FunctionCallInvoke(fcinfo);
1346
1347 /* Check for null result, since caller is clearly not expecting one */
1348 if (fcinfo->isnull)
1349 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1350
1351 return result;
1352}
1353
1354Datum
1355 FunctionCall9Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2,
1356 Datum arg3, Datum arg4, Datum arg5,
1357 Datum arg6, Datum arg7, Datum arg8,
1358 Datum arg9)
1359{
1360 LOCAL_FCINFO(fcinfo, 9);
1361 Datum result;
1362
1363 InitFunctionCallInfoData(*fcinfo, flinfo, 9, collation, NULL, NULL);
1364
1365 fcinfo->args[0].value = arg1;
1366 fcinfo->args[0].isnull = false;
1367 fcinfo->args[1].value = arg2;
1368 fcinfo->args[1].isnull = false;
1369 fcinfo->args[2].value = arg3;
1370 fcinfo->args[2].isnull = false;
1371 fcinfo->args[3].value = arg4;
1372 fcinfo->args[3].isnull = false;
1373 fcinfo->args[4].value = arg5;
1374 fcinfo->args[4].isnull = false;
1375 fcinfo->args[5].value = arg6;
1376 fcinfo->args[5].isnull = false;
1377 fcinfo->args[6].value = arg7;
1378 fcinfo->args[6].isnull = false;
1379 fcinfo->args[7].value = arg8;
1380 fcinfo->args[7].isnull = false;
1381 fcinfo->args[8].value = arg9;
1382 fcinfo->args[8].isnull = false;
1383
1384 result = FunctionCallInvoke(fcinfo);
1385
1386 /* Check for null result, since caller is clearly not expecting one */
1387 if (fcinfo->isnull)
1388 elog(ERROR, "function %u returned NULL", flinfo->fn_oid);
1389
1390 return result;
1391}
1392
1393
1394/*
1395 * These are for invocation of a function identified by OID with a
1396 * directly-computed parameter list. Note that neither arguments nor result
1397 * are allowed to be NULL. These are essentially fmgr_info() followed
1398 * by FunctionCallN(). If the same function is to be invoked repeatedly,
1399 * do the fmgr_info() once and then use FunctionCallN().
1400 */
1401Datum
1402 OidFunctionCall0Coll(Oid functionId, Oid collation)
1403{
1404 FmgrInfo flinfo;
1405
1406 fmgr_info(functionId, &flinfo);
1407
1408 return FunctionCall0Coll(&flinfo, collation);
1409}
1410
1411Datum
1412 OidFunctionCall1Coll(Oid functionId, Oid collation, Datum arg1)
1413{
1414 FmgrInfo flinfo;
1415
1416 fmgr_info(functionId, &flinfo);
1417
1418 return FunctionCall1Coll(&flinfo, collation, arg1);
1419}
1420
1421Datum
1422 OidFunctionCall2Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2)
1423{
1424 FmgrInfo flinfo;
1425
1426 fmgr_info(functionId, &flinfo);
1427
1428 return FunctionCall2Coll(&flinfo, collation, arg1, arg2);
1429}
1430
1431Datum
1432 OidFunctionCall3Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1433 Datum arg3)
1434{
1435 FmgrInfo flinfo;
1436
1437 fmgr_info(functionId, &flinfo);
1438
1439 return FunctionCall3Coll(&flinfo, collation, arg1, arg2, arg3);
1440}
1441
1442Datum
1443 OidFunctionCall4Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1444 Datum arg3, Datum arg4)
1445{
1446 FmgrInfo flinfo;
1447
1448 fmgr_info(functionId, &flinfo);
1449
1450 return FunctionCall4Coll(&flinfo, collation, arg1, arg2, arg3, arg4);
1451}
1452
1453Datum
1454 OidFunctionCall5Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1455 Datum arg3, Datum arg4, Datum arg5)
1456{
1457 FmgrInfo flinfo;
1458
1459 fmgr_info(functionId, &flinfo);
1460
1461 return FunctionCall5Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5);
1462}
1463
1464Datum
1465 OidFunctionCall6Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1466 Datum arg3, Datum arg4, Datum arg5,
1467 Datum arg6)
1468{
1469 FmgrInfo flinfo;
1470
1471 fmgr_info(functionId, &flinfo);
1472
1473 return FunctionCall6Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5,
1474 arg6);
1475}
1476
1477Datum
1478 OidFunctionCall7Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1479 Datum arg3, Datum arg4, Datum arg5,
1480 Datum arg6, Datum arg7)
1481{
1482 FmgrInfo flinfo;
1483
1484 fmgr_info(functionId, &flinfo);
1485
1486 return FunctionCall7Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5,
1487 arg6, arg7);
1488}
1489
1490Datum
1491 OidFunctionCall8Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1492 Datum arg3, Datum arg4, Datum arg5,
1493 Datum arg6, Datum arg7, Datum arg8)
1494{
1495 FmgrInfo flinfo;
1496
1497 fmgr_info(functionId, &flinfo);
1498
1499 return FunctionCall8Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5,
1500 arg6, arg7, arg8);
1501}
1502
1503Datum
1504 OidFunctionCall9Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2,
1505 Datum arg3, Datum arg4, Datum arg5,
1506 Datum arg6, Datum arg7, Datum arg8,
1507 Datum arg9)
1508{
1509 FmgrInfo flinfo;
1510
1511 fmgr_info(functionId, &flinfo);
1512
1513 return FunctionCall9Coll(&flinfo, collation, arg1, arg2, arg3, arg4, arg5,
1514 arg6, arg7, arg8, arg9);
1515}
1516
1517
1518/*
1519 * Special cases for convenient invocation of datatype I/O functions.
1520 */
1521
1522/*
1523 * Call a previously-looked-up datatype input function.
1524 *
1525 * "str" may be NULL to indicate we are reading a NULL. In this case
1526 * the caller should assume the result is NULL, but we'll call the input
1527 * function anyway if it's not strict. So this is almost but not quite
1528 * the same as FunctionCall3.
1529 */
1530Datum
1531 InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
1532{
1533 LOCAL_FCINFO(fcinfo, 3);
1534 Datum result;
1535
1536 if (str == NULL && flinfo->fn_strict)
1537 return (Datum) 0; /* just return null result */
1538
1539 InitFunctionCallInfoData(*fcinfo, flinfo, 3, InvalidOid, NULL, NULL);
1540
1541 fcinfo->args[0].value = CStringGetDatum(str);
1542 fcinfo->args[0].isnull = false;
1543 fcinfo->args[1].value = ObjectIdGetDatum(typioparam);
1544 fcinfo->args[1].isnull = false;
1545 fcinfo->args[2].value = Int32GetDatum(typmod);
1546 fcinfo->args[2].isnull = false;
1547
1548 result = FunctionCallInvoke(fcinfo);
1549
1550 /* Should get null result if and only if str is NULL */
1551 if (str == NULL)
1552 {
1553 if (!fcinfo->isnull)
1554 elog(ERROR, "input function %u returned non-NULL",
1555 flinfo->fn_oid);
1556 }
1557 else
1558 {
1559 if (fcinfo->isnull)
1560 elog(ERROR, "input function %u returned NULL",
1561 flinfo->fn_oid);
1562 }
1563
1564 return result;
1565}
1566
1567/*
1568 * Call a previously-looked-up datatype input function, with non-exception
1569 * handling of "soft" errors.
1570 *
1571 * This is basically like InputFunctionCall, but the converted Datum is
1572 * returned into *result while the function result is true for success or
1573 * false for failure. Also, the caller may pass an ErrorSaveContext node.
1574 *
1575 * If escontext points to an ErrorSaveContext, any "soft" errors detected by
1576 * the input function will be reported by filling the escontext struct and
1577 * returning false. (The caller can choose to test SOFT_ERROR_OCCURRED(),
1578 * but checking the function result instead is usually cheaper.)
1579 *
1580 * If escontext does not point to an ErrorSaveContext, errors are reported
1581 * via ereport(ERROR), so that there is no functional difference from
1582 * InputFunctionCall; the result will always be true if control returns.
1583 */
1584bool
1585 InputFunctionCallSafe(FmgrInfo *flinfo, char *str,
1586 Oid typioparam, int32 typmod,
1587 Node *escontext,
1588 Datum *result)
1589{
1590 LOCAL_FCINFO(fcinfo, 3);
1591
1592 if (str == NULL && flinfo->fn_strict)
1593 {
1594 *result = (Datum) 0; /* just return null result */
1595 return true;
1596 }
1597
1598 InitFunctionCallInfoData(*fcinfo, flinfo, 3, InvalidOid, escontext, NULL);
1599
1600 fcinfo->args[0].value = CStringGetDatum(str);
1601 fcinfo->args[0].isnull = false;
1602 fcinfo->args[1].value = ObjectIdGetDatum(typioparam);
1603 fcinfo->args[1].isnull = false;
1604 fcinfo->args[2].value = Int32GetDatum(typmod);
1605 fcinfo->args[2].isnull = false;
1606
1607 *result = FunctionCallInvoke(fcinfo);
1608
1609 /* Result value is garbage, and could be null, if an error was reported */
1610 if (SOFT_ERROR_OCCURRED(escontext))
1611 return false;
1612
1613 /* Otherwise, should get null result if and only if str is NULL */
1614 if (str == NULL)
1615 {
1616 if (!fcinfo->isnull)
1617 elog(ERROR, "input function %u returned non-NULL",
1618 flinfo->fn_oid);
1619 }
1620 else
1621 {
1622 if (fcinfo->isnull)
1623 elog(ERROR, "input function %u returned NULL",
1624 flinfo->fn_oid);
1625 }
1626
1627 return true;
1628}
1629
1630/*
1631 * Call a directly-named datatype input function, with non-exception
1632 * handling of "soft" errors.
1633 *
1634 * This is like InputFunctionCallSafe, except that it is given a direct
1635 * pointer to the C function to call. We assume that that function is
1636 * strict. Also, the function cannot be one that needs to
1637 * look at FmgrInfo, since there won't be any.
1638 */
1639bool
1640 DirectInputFunctionCallSafe(PGFunction func, char *str,
1641 Oid typioparam, int32 typmod,
1642 Node *escontext,
1643 Datum *result)
1644{
1645 LOCAL_FCINFO(fcinfo, 3);
1646
1647 if (str == NULL)
1648 {
1649 *result = (Datum) 0; /* just return null result */
1650 return true;
1651 }
1652
1653 InitFunctionCallInfoData(*fcinfo, NULL, 3, InvalidOid, escontext, NULL);
1654
1655 fcinfo->args[0].value = CStringGetDatum(str);
1656 fcinfo->args[0].isnull = false;
1657 fcinfo->args[1].value = ObjectIdGetDatum(typioparam);
1658 fcinfo->args[1].isnull = false;
1659 fcinfo->args[2].value = Int32GetDatum(typmod);
1660 fcinfo->args[2].isnull = false;
1661
1662 *result = (*func) (fcinfo);
1663
1664 /* Result value is garbage, and could be null, if an error was reported */
1665 if (SOFT_ERROR_OCCURRED(escontext))
1666 return false;
1667
1668 /* Otherwise, shouldn't get null result */
1669 if (fcinfo->isnull)
1670 elog(ERROR, "input function %p returned NULL", (void *) func);
1671
1672 return true;
1673}
1674
1675/*
1676 * Call a previously-looked-up datatype output function.
1677 *
1678 * Do not call this on NULL datums.
1679 *
1680 * This is currently little more than window dressing for FunctionCall1.
1681 */
1682char *
1683 OutputFunctionCall(FmgrInfo *flinfo, Datum val)
1684{
1685 return DatumGetCString(FunctionCall1(flinfo, val));
1686}
1687
1688/*
1689 * Call a previously-looked-up datatype binary-input function.
1690 *
1691 * "buf" may be NULL to indicate we are reading a NULL. In this case
1692 * the caller should assume the result is NULL, but we'll call the receive
1693 * function anyway if it's not strict. So this is almost but not quite
1694 * the same as FunctionCall3.
1695 */
1696Datum
1697 ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf,
1698 Oid typioparam, int32 typmod)
1699{
1700 LOCAL_FCINFO(fcinfo, 3);
1701 Datum result;
1702
1703 if (buf == NULL && flinfo->fn_strict)
1704 return (Datum) 0; /* just return null result */
1705
1706 InitFunctionCallInfoData(*fcinfo, flinfo, 3, InvalidOid, NULL, NULL);
1707
1708 fcinfo->args[0].value = PointerGetDatum(buf);
1709 fcinfo->args[0].isnull = false;
1710 fcinfo->args[1].value = ObjectIdGetDatum(typioparam);
1711 fcinfo->args[1].isnull = false;
1712 fcinfo->args[2].value = Int32GetDatum(typmod);
1713 fcinfo->args[2].isnull = false;
1714
1715 result = FunctionCallInvoke(fcinfo);
1716
1717 /* Should get null result if and only if buf is NULL */
1718 if (buf == NULL)
1719 {
1720 if (!fcinfo->isnull)
1721 elog(ERROR, "receive function %u returned non-NULL",
1722 flinfo->fn_oid);
1723 }
1724 else
1725 {
1726 if (fcinfo->isnull)
1727 elog(ERROR, "receive function %u returned NULL",
1728 flinfo->fn_oid);
1729 }
1730
1731 return result;
1732}
1733
1734/*
1735 * Call a previously-looked-up datatype binary-output function.
1736 *
1737 * Do not call this on NULL datums.
1738 *
1739 * This is little more than window dressing for FunctionCall1, but it does
1740 * guarantee a non-toasted result, which strictly speaking the underlying
1741 * function doesn't.
1742 */
1743bytea *
1744 SendFunctionCall(FmgrInfo *flinfo, Datum val)
1745{
1746 return DatumGetByteaP(FunctionCall1(flinfo, val));
1747}
1748
1749/*
1750 * As above, for I/O functions identified by OID. These are only to be used
1751 * in seldom-executed code paths. They are not only slow but leak memory.
1752 */
1753Datum
1754 OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
1755{
1756 FmgrInfo flinfo;
1757
1758 fmgr_info(functionId, &flinfo);
1759 return InputFunctionCall(&flinfo, str, typioparam, typmod);
1760}
1761
1762char *
1763 OidOutputFunctionCall(Oid functionId, Datum val)
1764{
1765 FmgrInfo flinfo;
1766
1767 fmgr_info(functionId, &flinfo);
1768 return OutputFunctionCall(&flinfo, val);
1769}
1770
1771Datum
1772 OidReceiveFunctionCall(Oid functionId, StringInfo buf,
1773 Oid typioparam, int32 typmod)
1774{
1775 FmgrInfo flinfo;
1776
1777 fmgr_info(functionId, &flinfo);
1778 return ReceiveFunctionCall(&flinfo, buf, typioparam, typmod);
1779}
1780
1781bytea *
1782 OidSendFunctionCall(Oid functionId, Datum val)
1783{
1784 FmgrInfo flinfo;
1785
1786 fmgr_info(functionId, &flinfo);
1787 return SendFunctionCall(&flinfo, val);
1788}
1789
1790
1791/*-------------------------------------------------------------------------
1792 * Support routines for toastable datatypes
1793 *-------------------------------------------------------------------------
1794 */
1795
1796struct varlena *
1797 pg_detoast_datum(struct varlena *datum)
1798{
1799 if (VARATT_IS_EXTENDED(datum))
1800 return detoast_attr(datum);
1801 else
1802 return datum;
1803}
1804
1805struct varlena *
1806 pg_detoast_datum_copy(struct varlena *datum)
1807{
1808 if (VARATT_IS_EXTENDED(datum))
1809 return detoast_attr(datum);
1810 else
1811 {
1812 /* Make a modifiable copy of the varlena object */
1813 Size len = VARSIZE(datum);
1814 struct varlena *result = (struct varlena *) palloc(len);
1815
1816 memcpy(result, datum, len);
1817 return result;
1818 }
1819}
1820
1821struct varlena *
1822 pg_detoast_datum_slice(struct varlena *datum, int32 first, int32 count)
1823{
1824 /* Only get the specified portion from the toast rel */
1825 return detoast_attr_slice(datum, first, count);
1826}
1827
1828struct varlena *
1829 pg_detoast_datum_packed(struct varlena *datum)
1830{
1831 if (VARATT_IS_COMPRESSED(datum) || VARATT_IS_EXTERNAL(datum))
1832 return detoast_attr(datum);
1833 else
1834 return datum;
1835}
1836
1837/*-------------------------------------------------------------------------
1838 * Support routines for extracting info from fn_expr parse tree
1839 *
1840 * These are needed by polymorphic functions, which accept multiple possible
1841 * input types and need help from the parser to know what they've got.
1842 * Also, some functions might be interested in whether a parameter is constant.
1843 * Functions taking VARIADIC ANY also need to know about the VARIADIC keyword.
1844 *-------------------------------------------------------------------------
1845 */
1846
1847/*
1848 * Get the actual type OID of the function return type
1849 *
1850 * Returns InvalidOid if information is not available
1851 */
1852Oid
1853 get_fn_expr_rettype(FmgrInfo *flinfo)
1854{
1855 Node *expr;
1856
1857 /*
1858 * can't return anything useful if we have no FmgrInfo or if its fn_expr
1859 * node has not been initialized
1860 */
1861 if (!flinfo || !flinfo->fn_expr)
1862 return InvalidOid;
1863
1864 expr = flinfo->fn_expr;
1865
1866 return exprType(expr);
1867}
1868
1869/*
1870 * Get the actual type OID of a specific function argument (counting from 0)
1871 *
1872 * Returns InvalidOid if information is not available
1873 */
1874Oid
1875 get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
1876{
1877 /*
1878 * can't return anything useful if we have no FmgrInfo or if its fn_expr
1879 * node has not been initialized
1880 */
1881 if (!flinfo || !flinfo->fn_expr)
1882 return InvalidOid;
1883
1884 return get_call_expr_argtype(flinfo->fn_expr, argnum);
1885}
1886
1887/*
1888 * Get the actual type OID of a specific function argument (counting from 0),
1889 * but working from the calling expression tree instead of FmgrInfo
1890 *
1891 * Returns InvalidOid if information is not available
1892 */
1893Oid
1894 get_call_expr_argtype(Node *expr, int argnum)
1895{
1896 List *args;
1897 Oid argtype;
1898
1899 if (expr == NULL)
1900 return InvalidOid;
1901
1902 if (IsA(expr, FuncExpr))
1903 args = ((FuncExpr *) expr)->args;
1904 else if (IsA(expr, OpExpr))
1905 args = ((OpExpr *) expr)->args;
1906 else if (IsA(expr, DistinctExpr))
1907 args = ((DistinctExpr *) expr)->args;
1908 else if (IsA(expr, ScalarArrayOpExpr))
1909 args = ((ScalarArrayOpExpr *) expr)->args;
1910 else if (IsA(expr, NullIfExpr))
1911 args = ((NullIfExpr *) expr)->args;
1912 else if (IsA(expr, WindowFunc))
1913 args = ((WindowFunc *) expr)->args;
1914 else
1915 return InvalidOid;
1916
1917 if (argnum < 0 || argnum >= list_length(args))
1918 return InvalidOid;
1919
1920 argtype = exprType((Node *) list_nth(args, argnum));
1921
1922 /*
1923 * special hack for ScalarArrayOpExpr: what the underlying function will
1924 * actually get passed is the element type of the array.
1925 */
1926 if (IsA(expr, ScalarArrayOpExpr) &&
1927 argnum == 1)
1928 argtype = get_base_element_type(argtype);
1929
1930 return argtype;
1931}
1932
1933/*
1934 * Find out whether a specific function argument is constant for the
1935 * duration of a query
1936 *
1937 * Returns false if information is not available
1938 */
1939bool
1940 get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum)
1941{
1942 /*
1943 * can't return anything useful if we have no FmgrInfo or if its fn_expr
1944 * node has not been initialized
1945 */
1946 if (!flinfo || !flinfo->fn_expr)
1947 return false;
1948
1949 return get_call_expr_arg_stable(flinfo->fn_expr, argnum);
1950}
1951
1952/*
1953 * Find out whether a specific function argument is constant for the
1954 * duration of a query, but working from the calling expression tree
1955 *
1956 * Returns false if information is not available
1957 */
1958bool
1959 get_call_expr_arg_stable(Node *expr, int argnum)
1960{
1961 List *args;
1962 Node *arg;
1963
1964 if (expr == NULL)
1965 return false;
1966
1967 if (IsA(expr, FuncExpr))
1968 args = ((FuncExpr *) expr)->args;
1969 else if (IsA(expr, OpExpr))
1970 args = ((OpExpr *) expr)->args;
1971 else if (IsA(expr, DistinctExpr))
1972 args = ((DistinctExpr *) expr)->args;
1973 else if (IsA(expr, ScalarArrayOpExpr))
1974 args = ((ScalarArrayOpExpr *) expr)->args;
1975 else if (IsA(expr, NullIfExpr))
1976 args = ((NullIfExpr *) expr)->args;
1977 else if (IsA(expr, WindowFunc))
1978 args = ((WindowFunc *) expr)->args;
1979 else
1980 return false;
1981
1982 if (argnum < 0 || argnum >= list_length(args))
1983 return false;
1984
1985 arg = (Node *) list_nth(args, argnum);
1986
1987 /*
1988 * Either a true Const or an external Param will have a value that doesn't
1989 * change during the execution of the query. In future we might want to
1990 * consider other cases too, e.g. now().
1991 */
1992 if (IsA(arg, Const))
1993 return true;
1994 if (IsA(arg, Param) &&
1995 ((Param *) arg)->paramkind == PARAM_EXTERN)
1996 return true;
1997
1998 return false;
1999}
2000
2001/*
2002 * Get the VARIADIC flag from the function invocation
2003 *
2004 * Returns false (the default assumption) if information is not available
2005 *
2006 * Note this is generally only of interest to VARIADIC ANY functions
2007 */
2008bool
2009 get_fn_expr_variadic(FmgrInfo *flinfo)
2010{
2011 Node *expr;
2012
2013 /*
2014 * can't return anything useful if we have no FmgrInfo or if its fn_expr
2015 * node has not been initialized
2016 */
2017 if (!flinfo || !flinfo->fn_expr)
2018 return false;
2019
2020 expr = flinfo->fn_expr;
2021
2022 if (IsA(expr, FuncExpr))
2023 return ((FuncExpr *) expr)->funcvariadic;
2024 else
2025 return false;
2026}
2027
2028/*
2029 * Set options to FmgrInfo of opclass support function.
2030 *
2031 * Opclass support functions are called outside of expressions. Thanks to that
2032 * we can use fn_expr to store opclass options as bytea constant.
2033 */
2034void
2035 set_fn_opclass_options(FmgrInfo *flinfo, bytea *options)
2036{
2037 flinfo->fn_expr = (Node *) makeConst(BYTEAOID, -1, InvalidOid, -1,
2038 PointerGetDatum(options),
2039 options == NULL, false);
2040}
2041
2042/*
2043 * Check if options are defined for opclass support function.
2044 */
2045bool
2046 has_fn_opclass_options(FmgrInfo *flinfo)
2047{
2048 if (flinfo && flinfo->fn_expr && IsA(flinfo->fn_expr, Const))
2049 {
2050 Const *expr = (Const *) flinfo->fn_expr;
2051
2052 if (expr->consttype == BYTEAOID)
2053 return !expr->constisnull;
2054 }
2055 return false;
2056}
2057
2058/*
2059 * Get options for opclass support function.
2060 */
2061bytea *
2062 get_fn_opclass_options(FmgrInfo *flinfo)
2063{
2064 if (flinfo && flinfo->fn_expr && IsA(flinfo->fn_expr, Const))
2065 {
2066 Const *expr = (Const *) flinfo->fn_expr;
2067
2068 if (expr->consttype == BYTEAOID)
2069 return expr->constisnull ? NULL : DatumGetByteaP(expr->constvalue);
2070 }
2071
2072 ereport(ERROR,
2073 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2074 errmsg("operator class options info is absent in function call context")));
2075
2076 return NULL;
2077}
2078
2079/*-------------------------------------------------------------------------
2080 * Support routines for procedural language implementations
2081 *-------------------------------------------------------------------------
2082 */
2083
2084/*
2085 * Verify that a validator is actually associated with the language of a
2086 * particular function and that the user has access to both the language and
2087 * the function. All validators should call this before doing anything
2088 * substantial. Doing so ensures a user cannot achieve anything with explicit
2089 * calls to validators that he could not achieve with CREATE FUNCTION or by
2090 * simply calling an existing function.
2091 *
2092 * When this function returns false, callers should skip all validation work
2093 * and call PG_RETURN_VOID(). This never happens at present; it is reserved
2094 * for future expansion.
2095 *
2096 * In particular, checking that the validator corresponds to the function's
2097 * language allows untrusted language validators to assume they process only
2098 * superuser-chosen source code. (Untrusted language call handlers, by
2099 * definition, do assume that.) A user lacking the USAGE language privilege
2100 * would be unable to reach the validator through CREATE FUNCTION, so we check
2101 * that to block explicit calls as well. Checking the EXECUTE privilege on
2102 * the function is often superfluous, because most users can clone the
2103 * function to get an executable copy. It is meaningful against users with no
2104 * database TEMP right and no permanent schema CREATE right, thereby unable to
2105 * create any function. Also, if the function tracks persistent state by
2106 * function OID or name, validating the original function might permit more
2107 * mischief than creating and validating a clone thereof.
2108 */
2109bool
2110 CheckFunctionValidatorAccess(Oid validatorOid, Oid functionOid)
2111{
2112 HeapTuple procTup;
2113 HeapTuple langTup;
2114 Form_pg_proc procStruct;
2115 Form_pg_language langStruct;
2116 AclResult aclresult;
2117
2118 /*
2119 * Get the function's pg_proc entry. Throw a user-facing error for bad
2120 * OID, because validators can be called with user-specified OIDs.
2121 */
2122 procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(functionOid));
2123 if (!HeapTupleIsValid(procTup))
2124 ereport(ERROR,
2125 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2126 errmsg("function with OID %u does not exist", functionOid)));
2127 procStruct = (Form_pg_proc) GETSTRUCT(procTup);
2128
2129 /*
2130 * Fetch pg_language entry to know if this is the correct validation
2131 * function for that pg_proc entry.
2132 */
2133 langTup = SearchSysCache1(LANGOID, ObjectIdGetDatum(procStruct->prolang));
2134 if (!HeapTupleIsValid(langTup))
2135 elog(ERROR, "cache lookup failed for language %u", procStruct->prolang);
2136 langStruct = (Form_pg_language) GETSTRUCT(langTup);
2137
2138 if (langStruct->lanvalidator != validatorOid)
2139 ereport(ERROR,
2140 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2141 errmsg("language validation function %u called for language %u instead of %u",
2142 validatorOid, procStruct->prolang,
2143 langStruct->lanvalidator)));
2144
2145 /* first validate that we have permissions to use the language */
2146 aclresult = object_aclcheck(LanguageRelationId, procStruct->prolang, GetUserId(),
2147 ACL_USAGE);
2148 if (aclresult != ACLCHECK_OK)
2149 aclcheck_error(aclresult, OBJECT_LANGUAGE,
2150 NameStr(langStruct->lanname));
2151
2152 /*
2153 * Check whether we are allowed to execute the function itself. If we can
2154 * execute it, there should be no possible side-effect of
2155 * compiling/validation that execution can't have.
2156 */
2157 aclresult = object_aclcheck(ProcedureRelationId, functionOid, GetUserId(), ACL_EXECUTE);
2158 if (aclresult != ACLCHECK_OK)
2159 aclcheck_error(aclresult, OBJECT_FUNCTION, NameStr(procStruct->proname));
2160
2161 ReleaseSysCache(procTup);
2162 ReleaseSysCache(langTup);
2163
2164 return true;
2165}
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2652
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3834
#define DatumGetArrayTypeP(X)
Definition: array.h:261
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define NameStr(name)
Definition: c.h:751
#define PGDLLIMPORT
Definition: c.h:1319
int32_t int32
Definition: c.h:534
uint16_t uint16
Definition: c.h:537
uint32 TransactionId
Definition: c.h:657
#define OidIsValid(objectId)
Definition: c.h:774
size_t Size
Definition: c.h:610
struct varlena * detoast_attr(struct varlena *attr)
Definition: detoast.c:116
struct varlena * detoast_attr_slice(struct varlena *attr, int32 sliceoffset, int32 slicelength)
Definition: detoast.c:205
void * lookup_external_function(void *filehandle, const char *funcname)
Definition: dfmgr.c:171
void * load_external_function(const char *filename, const char *funcname, bool signalNotFound, void **filehandle)
Definition: dfmgr.c:95
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:952
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:358
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define PG_RE_THROW()
Definition: elog.h:405
#define PG_TRY(...)
Definition: elog.h:372
#define PG_END_TRY(...)
Definition: elog.h:397
#define ERROR
Definition: elog.h:39
#define PG_CATCH(...)
Definition: elog.h:382
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:150
@ ExprMultipleResult
Definition: execnodes.h:328
Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:1197
Datum OidFunctionCall2Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1422
void set_fn_opclass_options(FmgrInfo *flinfo, bytea *options)
Definition: fmgr.c:2035
Oid fmgr_internal_function(const char *proname)
Definition: fmgr.c:596
Datum OidFunctionCall9Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7, Datum arg8, Datum arg9)
Definition: fmgr.c:1504
bool get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1940
struct varlena * pg_detoast_datum_copy(struct varlena *datum)
Definition: fmgr.c:1806
struct varlena * pg_detoast_datum_slice(struct varlena *datum, int32 first, int32 count)
Definition: fmgr.c:1822
Datum OidFunctionCall6Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6)
Definition: fmgr.c:1465
Datum FunctionCall6Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6)
Definition: fmgr.c:1253
Datum OidFunctionCall5Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5)
Definition: fmgr.c:1454
Datum FunctionCall8Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7, Datum arg8)
Definition: fmgr.c:1319
bool CheckFunctionValidatorAccess(Oid validatorOid, Oid functionOid)
Definition: fmgr.c:2110
Datum OidReceiveFunctionCall(Oid functionId, StringInfo buf, Oid typioparam, int32 typmod)
Definition: fmgr.c:1772
Datum InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1531
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1150
static const FmgrBuiltin * fmgr_lookupByName(const char *name)
Definition: fmgr.c:102
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:128
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1754
PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook
Definition: fmgr.c:40
Datum DirectFunctionCall2Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:813
static void fmgr_info_C_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple)
Definition: fmgr.c:350
bool DirectInputFunctionCallSafe(PGFunction func, char *str, Oid typioparam, int32 typmod, Node *escontext, Datum *result)
Definition: fmgr.c:1640
struct varlena * pg_detoast_datum_packed(struct varlena *datum)
Definition: fmgr.c:1829
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1763
Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5)
Definition: fmgr.c:1224
static void fmgr_info_other_lang(Oid functionId, FmgrInfo *finfo, HeapTuple procedureTuple)
Definition: fmgr.c:419
const Pg_finfo_record * fetch_finfo_record(void *filehandle, const char *funcname)
Definition: fmgr.c:456
struct varlena * pg_detoast_datum(struct varlena *datum)
Definition: fmgr.c:1797
Datum OidFunctionCall3Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition: fmgr.c:1432
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:138
Datum OidFunctionCall8Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7, Datum arg8)
Definition: fmgr.c:1491
bytea * SendFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1744
Datum OidFunctionCall4Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:1443
Datum DirectFunctionCall4Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:860
Datum OidFunctionCall7Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7)
Definition: fmgr.c:1478
PGDLLIMPORT fmgr_hook_type fmgr_hook
Definition: fmgr.c:41
bool has_fn_opclass_options(FmgrInfo *flinfo)
Definition: fmgr.c:2046
bool InputFunctionCallSafe(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod, Node *escontext, Datum *result)
Definition: fmgr.c:1585
Datum CallerFInfoFunctionCall2(PGFunction func, FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition: fmgr.c:1086
Datum CallerFInfoFunctionCall1(PGFunction func, FmgrInfo *flinfo, Oid collation, Datum arg1)
Definition: fmgr.c:1066
Datum DirectFunctionCall6Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6)
Definition: fmgr.c:916
Datum DirectFunctionCall5Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5)
Definition: fmgr.c:887
static HTAB * CFuncHash
Definition: fmgr.c:56
Datum OidFunctionCall1Coll(Oid functionId, Oid collation, Datum arg1)
Definition: fmgr.c:1412
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition: fmgr.c:1683
bool get_fn_expr_variadic(FmgrInfo *flinfo)
Definition: fmgr.c:2009
Datum DirectFunctionCall1Coll(PGFunction func, Oid collation, Datum arg1)
Definition: fmgr.c:793
bytea * get_fn_opclass_options(FmgrInfo *flinfo)
Definition: fmgr.c:2062
Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition: fmgr.c:1172
Datum DirectFunctionCall3Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition: fmgr.c:835
Oid get_call_expr_argtype(Node *expr, int argnum)
Definition: fmgr.c:1894
Datum FunctionCall7Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7)
Definition: fmgr.c:1285
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition: fmgr.c:1875
Datum OidFunctionCall0Coll(Oid functionId, Oid collation)
Definition: fmgr.c:1402
void fmgr_symbol(Oid functionId, char **mod, char **fn)
Definition: fmgr.c:282
Datum DirectFunctionCall9Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7, Datum arg8, Datum arg9)
Definition: fmgr.c:1018
bytea * OidSendFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1782
Datum FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, Datum arg1)
Definition: fmgr.c:1130
Datum fmgr_security_definer(PG_FUNCTION_ARGS)
Definition: fmgr.c:633
Oid get_fn_expr_rettype(FmgrInfo *flinfo)
Definition: fmgr.c:1853
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition: fmgr.c:581
static void record_C_func(HeapTuple procedureTuple, PGFunction user_fn, const Pg_finfo_record *inforec)
Definition: fmgr.c:540
static void fmgr_info_cxt_security(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt, bool ignore_security)
Definition: fmgr.c:148
Datum FunctionCall0Coll(FmgrInfo *flinfo, Oid collation)
Definition: fmgr.c:1113
Datum FunctionCall9Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7, Datum arg8, Datum arg9)
Definition: fmgr.c:1355
Datum DirectFunctionCall7Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7)
Definition: fmgr.c:948
static CFuncHashTabEntry * lookup_C_func(HeapTuple procedureTuple)
Definition: fmgr.c:516
static const FmgrBuiltin * fmgr_isbuiltin(Oid id)
Definition: fmgr.c:77
bool get_call_expr_arg_stable(Node *expr, int argnum)
Definition: fmgr.c:1959
Datum ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf, Oid typioparam, int32 typmod)
Definition: fmgr.c:1697
Datum DirectFunctionCall8Coll(PGFunction func, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4, Datum arg5, Datum arg6, Datum arg7, Datum arg8)
Definition: fmgr.c:982
const Pg_finfo_record *(* PGFInfoFunction)(void)
Definition: fmgr.h:401
bool(* needs_fmgr_hook_type)(Oid fn_oid)
Definition: fmgr.h:840
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150
#define LOCAL_FCINFO(name, nargs)
Definition: fmgr.h:110
@ FHET_END
Definition: fmgr.h:836
@ FHET_ABORT
Definition: fmgr.h:837
@ FHET_START
Definition: fmgr.h:835
#define FunctionCall1(flinfo, arg1)
Definition: fmgr.h:700
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:172
void(* fmgr_hook_type)(FmgrHookEventType event, FmgrInfo *flinfo, Datum *arg)
Definition: fmgr.h:842
Datum(* PGFunction)(FunctionCallInfo fcinfo)
Definition: fmgr.h:40
#define FmgrHookIsNeeded(fn_oid)
Definition: fmgr.h:848
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define DatumGetByteaP(X)
Definition: fmgr.h:331
PGDLLIMPORT const Oid fmgr_last_builtin_oid
PGDLLIMPORT const int fmgr_nbuiltins
PGDLLIMPORT const FmgrBuiltin fmgr_builtins[]
#define InvalidOidBuiltinMapping
Definition: fmgrtab.h:46
PGDLLIMPORT const uint16 fmgr_builtin_oid_index[]
Datum fmgr_sql(PG_FUNCTION_ARGS)
Definition: functions.c:1576
int NewGUCNestLevel(void)
Definition: guc.c:2241
config_handle * get_config_handle(const char *name)
Definition: guc.c:4290
int set_config_with_handle(const char *name, config_handle *handle, const char *value, GucContext context, GucSource source, Oid srole, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition: guc.c:3411
void TransformGUCArray(ArrayType *array, List **names, List **values)
Definition: guc.c:6422
void AtEOXact_GUC(bool isCommit, int nestLevel)
Definition: guc.c:2268
GucAction
Definition: guc.h:201
@ GUC_ACTION_SAVE
Definition: guc.h:205
GucSource
Definition: guc.h:112
@ PGC_S_SESSION
Definition: guc.h:126
GucContext
Definition: guc.h:72
@ PGC_SUSET
Definition: guc.h:78
@ PGC_USERSET
Definition: guc.h:79
const char * str
bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition: heaptuple.c:456
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_ENTER
Definition: hsearch.h:114
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static TransactionId HeapTupleHeaderGetRawXmin(const HeapTupleHeaderData *tup)
Definition: htup_details.h:318
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
#define funcname
Definition: indent_codes.h:69
static struct @169 value
long val
Definition: informix.c:689
i
int i
Definition: isn.c:77
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
Definition: itemptr.c:35
List * lappend(List *list, void *datum)
Definition: list.c:339
Oid get_base_element_type(Oid typid)
Definition: lsyscache.c:2999
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:350
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1263
char * pstrdup(const char *in)
Definition: mcxt.c:1759
void pfree(void *pointer)
Definition: mcxt.c:1594
void * palloc(Size size)
Definition: mcxt.c:1365
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
#define SECURITY_LOCAL_USERID_CHANGE
Definition: miscadmin.h:317
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition: miscinit.c:612
Oid GetUserId(void)
Definition: miscinit.c:469
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition: miscinit.c:619
#define SOFT_ERROR_OCCURRED(escontext)
Definition: miscnodes.h:53
args
action
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
#define ACL_USAGE
Definition: parsenodes.h:84
@ OBJECT_LANGUAGE
Definition: parsenodes.h:2346
@ OBJECT_FUNCTION
Definition: parsenodes.h:2344
#define ACL_EXECUTE
Definition: parsenodes.h:83
void * arg
const void size_t len
FormData_pg_language * Form_pg_language
Definition: pg_language.h:65
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define forthree(cell1, list1, cell2, list2, cell3, list3)
Definition: pg_list.h:563
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
FormData_pg_proc * Form_pg_proc
Definition: pg_proc.h:136
NameData proname
Definition: pg_proc.h:35
static rewind_source * source
Definition: pg_rewind.c:89
static char * buf
Definition: pg_test_fsync.c:72
@ TRACK_FUNC_PL
Definition: pgstat.h:41
@ TRACK_FUNC_ALL
Definition: pgstat.h:42
@ TRACK_FUNC_OFF
Definition: pgstat.h:40
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
static char * DatumGetCString(Datum X)
Definition: postgres.h:345
uint64_t Datum
Definition: postgres.h:70
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:360
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:222
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
@ PARAM_EXTERN
Definition: primnodes.h:384
char * psprintf(const char *fmt,...)
Definition: psprintf.c:43
Definition: array.h:93
const Pg_finfo_record * inforec
Definition: fmgr.c:53
TransactionId fn_xmin
Definition: fmgr.c:50
ItemPointerData fn_tid
Definition: fmgr.c:51
PGFunction user_fn
Definition: fmgr.c:52
Oid fn_oid
Definition: fmgr.c:49
Definition: primnodes.h:324
Oid consttype
Definition: primnodes.h:329
bool strict
Definition: fmgrtab.h:29
bool retset
Definition: fmgrtab.h:30
PGFunction func
Definition: fmgrtab.h:32
Oid foid
Definition: fmgrtab.h:27
short nargs
Definition: fmgrtab.h:28
Definition: fmgr.h:57
void * fn_extra
Definition: fmgr.h:64
short fn_nargs
Definition: fmgr.h:60
PGFunction fn_addr
Definition: fmgr.h:58
Node * fn_expr
Definition: fmgr.h:66
unsigned char fn_stats
Definition: fmgr.h:63
MemoryContext fn_mcxt
Definition: fmgr.h:65
Oid fn_oid
Definition: fmgr.h:59
bool fn_retset
Definition: fmgr.h:62
bool fn_strict
Definition: fmgr.h:61
Definition: hsearch.h:66
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
Definition: dynahash.c:222
ItemPointerData t_self
Definition: htup.h:65
HeapTupleHeader t_data
Definition: htup.h:68
Definition: pg_list.h:54
Definition: nodes.h:135
Definition: primnodes.h:846
Definition: primnodes.h:391
Definition: pgstat.h:92
Definition: fmgr.h:395
int api_version
Definition: fmgr.h:396
Definition: guc_tables.h:172
Definition: fmgr.c:613
List * configHandles
Definition: fmgr.c:617
Datum arg
Definition: fmgr.c:619
FmgrInfo flinfo
Definition: fmgr.c:614
Oid userid
Definition: fmgr.c:615
List * configNames
Definition: fmgr.c:616
List * configValues
Definition: fmgr.c:618
Definition: type.h:96
Definition: oid2name.c:30
Definition: c.h:692
bool superuser(void)
Definition: superuser.c:46
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:264
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:220
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:595
Datum SysCacheGetAttrNotNull(int cacheId, HeapTuple tup, AttrNumber attributeNumber)
Definition: syscache.c:625
static void * fn(void *arg)
Definition: thread-alloc.c:119
Definition: pg_list.h:46
static bool VARATT_IS_EXTENDED(const void *PTR)
Definition: varatt.h:410
static bool VARATT_IS_EXTERNAL(const void *PTR)
Definition: varatt.h:354
static Size VARSIZE(const void *PTR)
Definition: varatt.h:298
static bool VARATT_IS_COMPRESSED(const void *PTR)
Definition: varatt.h:347
const char * name

AltStyle によって変換されたページ (->オリジナル) /