/*------------------------------------------------------------------------- * * funccache.c * Function cache management. * * funccache.c manages a cache of function execution data. The cache * is used by SQL-language and PL/pgSQL functions, and could be used by * other function languages. Each cache entry is specific to the execution * of a particular function (identified by OID) with specific input data * types; so a polymorphic function could have many associated cache entries. * Trigger functions similarly have a cache entry per trigger. These rules * allow the cached data to be specific to the particular data types the * function call will be dealing with. * * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION * src/backend/utils/cache/funccache.c * *------------------------------------------------------------------------- */ #include "postgres.h" #include "catalog/pg_proc.h" #include "commands/event_trigger.h" #include "commands/trigger.h" #include "common/hashfn.h" #include "funcapi.h" #include "utils/funccache.h" #include "utils/hsearch.h" #include "utils/syscache.h" /* * Hash table for cached functions */ static HTAB *cfunc_hashtable = NULL; typedef struct CachedFunctionHashEntry { CachedFunctionHashKey key; /* hash key, must be first */ CachedFunction *function; /* points to data of language-specific size */ } CachedFunctionHashEntry; #define FUNCS_PER_USER 128 /* initial table size */ static uint32 cfunc_hash(const void *key, Size keysize); static int cfunc_match(const void *key1, const void *key2, Size keysize); /* * Initialize the hash table on first use. * * The hash table will be in TopMemoryContext regardless of caller's context. */ static void cfunc_hashtable_init(void) { HASHCTL ctl; /* don't allow double-initialization */ Assert(cfunc_hashtable == NULL); ctl.keysize = sizeof(CachedFunctionHashKey); ctl.entrysize = sizeof(CachedFunctionHashEntry); ctl.hash = cfunc_hash; ctl.match = cfunc_match; cfunc_hashtable = hash_create("Cached function hash", FUNCS_PER_USER, &ctl, HASH_ELEM | HASH_FUNCTION | HASH_COMPARE); } /* * cfunc_hash: hash function for cfunc hash table * * We need special hash and match functions to deal with the optional * presence of a TupleDesc in the hash keys. As long as we have to do * that, we might as well also be smart about not comparing unused * elements of the argtypes arrays. */ static uint32 cfunc_hash(const void *key, Size keysize) { const CachedFunctionHashKey *k = (const CachedFunctionHashKey *) key; uint32 h; Assert(keysize == sizeof(CachedFunctionHashKey)); /* Hash all the fixed fields except callResultType */ h = DatumGetUInt32(hash_any((const unsigned char *) k, offsetof(CachedFunctionHashKey, callResultType))); /* Incorporate input argument types */ if (k->nargs > 0) h = hash_combine(h, DatumGetUInt32(hash_any((const unsigned char *) k->argtypes, k->nargs * sizeof(Oid)))); /* Incorporate callResultType if present */ if (k->callResultType) h = hash_combine(h, hashRowType(k->callResultType)); return h; } /* * cfunc_match: match function to use with cfunc_hash */ static int cfunc_match(const void *key1, const void *key2, Size keysize) { const CachedFunctionHashKey *k1 = (const CachedFunctionHashKey *) key1; const CachedFunctionHashKey *k2 = (const CachedFunctionHashKey *) key2; Assert(keysize == sizeof(CachedFunctionHashKey)); /* Compare all the fixed fields except callResultType */ if (memcmp(k1, k2, offsetof(CachedFunctionHashKey, callResultType)) != 0) return 1; /* not equal */ /* Compare input argument types (we just verified that nargs matches) */ if (k1->nargs > 0 && memcmp(k1->argtypes, k2->argtypes, k1->nargs * sizeof(Oid)) != 0) return 1; /* not equal */ /* Compare callResultType */ if (k1->callResultType) { if (k2->callResultType) { if (!equalRowTypes(k1->callResultType, k2->callResultType)) return 1; /* not equal */ } else return 1; /* not equal */ } else { if (k2->callResultType) return 1; /* not equal */ } return 0; /* equal */ } /* * Look up the CachedFunction for the given hash key. * Returns NULL if not present. */ static CachedFunction * cfunc_hashtable_lookup(CachedFunctionHashKey *func_key) { CachedFunctionHashEntry *hentry; if (cfunc_hashtable == NULL) return NULL; hentry = (CachedFunctionHashEntry *) hash_search(cfunc_hashtable, func_key, HASH_FIND, NULL); if (hentry) return hentry->function; else return NULL; } /* * Insert a hash table entry. */ static void cfunc_hashtable_insert(CachedFunction *function, CachedFunctionHashKey *func_key) { CachedFunctionHashEntry *hentry; bool found; if (cfunc_hashtable == NULL) cfunc_hashtable_init(); hentry = (CachedFunctionHashEntry *) hash_search(cfunc_hashtable, func_key, HASH_ENTER, &found); if (found) elog(WARNING, "trying to insert a function that already exists"); /* * If there's a callResultType, copy it into TopMemoryContext. If we're * unlucky enough for that to fail, leave the entry with null * callResultType, which will probably never match anything. */ if (func_key->callResultType) { MemoryContext oldcontext = MemoryContextSwitchTo(TopMemoryContext); hentry->key.callResultType = NULL; hentry->key.callResultType = CreateTupleDescCopy(func_key->callResultType); MemoryContextSwitchTo(oldcontext); } hentry->function = function; /* Set back-link from function to hashtable key */ function->fn_hashkey = &hentry->key; } /* * Delete a hash table entry. */ static void cfunc_hashtable_delete(CachedFunction *function) { CachedFunctionHashEntry *hentry; TupleDesc tupdesc; /* do nothing if not in table */ if (function->fn_hashkey == NULL) return; /* * We need to free the callResultType if present, which is slightly tricky * because it has to be valid during the hashtable search. Fortunately, * because we have the hashkey back-link, we can grab that pointer before * deleting the hashtable entry. */ tupdesc = function->fn_hashkey->callResultType; hentry = (CachedFunctionHashEntry *) hash_search(cfunc_hashtable, function->fn_hashkey, HASH_REMOVE, NULL); if (hentry == NULL) elog(WARNING, "trying to delete function that does not exist"); /* Remove back link, which no longer points to allocated storage */ function->fn_hashkey = NULL; /* Release the callResultType if present */ if (tupdesc) FreeTupleDesc(tupdesc); } /* * Compute the hashkey for a given function invocation * * The hashkey is returned into the caller-provided storage at *hashkey. * Note however that if a callResultType is incorporated, we've not done * anything about copying that. */ static void compute_function_hashkey(FunctionCallInfo fcinfo, Form_pg_proc procStruct, CachedFunctionHashKey *hashkey, Size cacheEntrySize, bool includeResultType, bool forValidator) { /* Make sure pad bytes within fixed part of the struct are zero */ memset(hashkey, 0, offsetof(CachedFunctionHashKey, argtypes)); /* get function OID */ hashkey->funcOid = fcinfo->flinfo->fn_oid; /* get call context */ hashkey->isTrigger = CALLED_AS_TRIGGER(fcinfo); hashkey->isEventTrigger = CALLED_AS_EVENT_TRIGGER(fcinfo); /* record cacheEntrySize so multiple languages can share hash table */ hashkey->cacheEntrySize = cacheEntrySize; /* * If DML trigger, include trigger's OID in the hash, so that each trigger * usage gets a different hash entry, allowing for e.g. different relation * rowtypes or transition table names. In validation mode we do not know * what relation or transition table names are intended to be used, so we * leave trigOid zero; the hash entry built in this case will never be * used for any actual calls. * * We don't currently need to distinguish different event trigger usages * in the same way, since the special parameter variables don't vary in * type in that case. */ if (hashkey->isTrigger && !forValidator) { TriggerData *trigdata = (TriggerData *) fcinfo->context; hashkey->trigOid = trigdata->tg_trigger->tgoid; } /* get input collation, if known */ hashkey->inputCollation = fcinfo->fncollation; /* * We include only input arguments in the hash key, since output argument * types can be deduced from those, and it would require extra cycles to * include the output arguments. But we have to resolve any polymorphic * argument types to the real types for the call. */ if (procStruct->pronargs > 0) { hashkey->nargs = procStruct->pronargs; memcpy(hashkey->argtypes, procStruct->proargtypes.values, procStruct->pronargs * sizeof(Oid)); cfunc_resolve_polymorphic_argtypes(procStruct->pronargs, hashkey->argtypes, NULL, /* all args are inputs */ fcinfo->flinfo->fn_expr, forValidator, NameStr(procStruct->proname)); } /* * While regular OUT arguments are sufficiently represented by the * resolved input arguments, a function returning composite has additional * variability: ALTER TABLE/ALTER TYPE could affect what it returns. Also, * a function returning RECORD may depend on a column definition list to * determine its output rowtype. If the caller needs the exact result * type to be part of the hash lookup key, we must run * get_call_result_type() to find that out. */ if (includeResultType) { Oid resultTypeId; TupleDesc tupdesc; switch (get_call_result_type(fcinfo, &resultTypeId, &tupdesc)) { case TYPEFUNC_COMPOSITE: case TYPEFUNC_COMPOSITE_DOMAIN: hashkey->callResultType = tupdesc; break; default: /* scalar result, or indeterminate rowtype */ break; } } } /* * This is the same as the standard resolve_polymorphic_argtypes() function, * except that: * 1. We go ahead and report the error if we can't resolve the types. * 2. We treat RECORD-type input arguments (not output arguments) as if * they were polymorphic, replacing their types with the actual input * types if we can determine those. This allows us to create a separate * function cache entry for each named composite type passed to such an * argument. * 3. In validation mode, we have no inputs to look at, so assume that * polymorphic arguments are integer, integer-array or integer-range. */ void cfunc_resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes, Node *call_expr, bool forValidator, const char *proname) { int i; if (!forValidator) { int inargno; /* normal case, pass to standard routine */ if (!resolve_polymorphic_argtypes(numargs, argtypes, argmodes, call_expr)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("could not determine actual argument " "type for polymorphic function \"%s\"", proname))); /* also, treat RECORD inputs (but not outputs) as polymorphic */ inargno = 0; for (i = 0; i < numargs; i++) { char argmode = argmodes ? argmodes[i] : PROARGMODE_IN; if (argmode == PROARGMODE_OUT || argmode == PROARGMODE_TABLE) continue; if (argtypes[i] == RECORDOID || argtypes[i] == RECORDARRAYOID) { Oid resolvedtype = get_call_expr_argtype(call_expr, inargno); if (OidIsValid(resolvedtype)) argtypes[i] = resolvedtype; } inargno++; } } else { /* special validation case (no need to do anything for RECORD) */ for (i = 0; i < numargs; i++) { switch (argtypes[i]) { case ANYELEMENTOID: case ANYNONARRAYOID: case ANYENUMOID: /* XXX dubious */ case ANYCOMPATIBLEOID: case ANYCOMPATIBLENONARRAYOID: argtypes[i] = INT4OID; break; case ANYARRAYOID: case ANYCOMPATIBLEARRAYOID: argtypes[i] = INT4ARRAYOID; break; case ANYRANGEOID: case ANYCOMPATIBLERANGEOID: argtypes[i] = INT4RANGEOID; break; case ANYMULTIRANGEOID: argtypes[i] = INT4MULTIRANGEOID; break; default: break; } } } } /* * delete_function - clean up as much as possible of a stale function cache * * We can't release the CachedFunction struct itself, because of the * possibility that there are fn_extra pointers to it. We can release * the subsidiary storage, but only if there are no active evaluations * in progress. Otherwise we'll just leak that storage. Since the * case would only occur if a pg_proc update is detected during a nested * recursive call on the function, a leak seems acceptable. * * Note that this can be called more than once if there are multiple fn_extra * pointers to the same function cache. Hence be careful not to do things * twice. */ static void delete_function(CachedFunction *func) { /* remove function from hash table (might be done already) */ cfunc_hashtable_delete(func); /* release the function's storage if safe and not done already */ if (func->use_count == 0 && func->dcallback != NULL) { func->dcallback(func); func->dcallback = NULL; } } /* * Compile a cached function, if no existing cache entry is suitable. * * fcinfo is the current call information. * * function should be NULL or the result of a previous call of * cached_function_compile() for the same fcinfo. The caller will * typically save the result in fcinfo->flinfo->fn_extra, or in a * field of a struct pointed to by fn_extra, to re-use in later * calls within the same query. * * ccallback and dcallback are function-language-specific callbacks to * compile and delete a cached function entry. dcallback can be NULL * if there's nothing for it to do. * * cacheEntrySize is the function-language-specific size of the cache entry * (which embeds a CachedFunction struct and typically has many more fields * after that). * * If includeResultType is true and the function returns composite, * include the actual result descriptor in the cache lookup key. * * If forValidator is true, we're only compiling for validation purposes, * and so some checks are skipped. * * Note: it's important for this to fall through quickly if the function * has already been compiled. * * Note: this function leaves the "use_count" field as zero. The caller * is expected to increment the use_count and decrement it when done with * the cache entry. */ CachedFunction * cached_function_compile(FunctionCallInfo fcinfo, CachedFunction *function, CachedFunctionCompileCallback ccallback, CachedFunctionDeleteCallback dcallback, Size cacheEntrySize, bool includeResultType, bool forValidator) { Oid funcOid = fcinfo->flinfo->fn_oid; HeapTuple procTup; Form_pg_proc procStruct; CachedFunctionHashKey hashkey; bool function_valid = false; bool hashkey_valid = false; bool new_function = false; /* * Lookup the pg_proc tuple by Oid; we'll need it in any case */ procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcOid)); if (!HeapTupleIsValid(procTup)) elog(ERROR, "cache lookup failed for function %u", funcOid); procStruct = (Form_pg_proc) GETSTRUCT(procTup); /* * Do we already have a cache entry for the current FmgrInfo? If not, try * to find one in the hash table. */ recheck: if (!function) { /* Compute hashkey using function signature and actual arg types */ compute_function_hashkey(fcinfo, procStruct, &hashkey, cacheEntrySize, includeResultType, forValidator); hashkey_valid = true; /* And do the lookup */ function = cfunc_hashtable_lookup(&hashkey); } if (function) { /* We have a compiled function, but is it still valid? */ if (function->fn_xmin == HeapTupleHeaderGetRawXmin(procTup->t_data) && ItemPointerEquals(&function->fn_tid, &procTup->t_self)) function_valid = true; else { /* * Nope, so remove it from hashtable and try to drop associated * storage (if not done already). */ delete_function(function); /* * If the function isn't in active use then we can overwrite the * func struct with new data, allowing any other existing fn_extra * pointers to make use of the new definition on their next use. * If it is in use then just leave it alone and make a new one. * (The active invocations will run to completion using the * previous definition, and then the cache entry will just be * leaked; doesn't seem worth adding code to clean it up, given * what a corner case this is.) * * If we found the function struct via fn_extra then it's possible * a replacement has already been made, so go back and recheck the * hashtable. */ if (function->use_count != 0) { function = NULL; if (!hashkey_valid) goto recheck; } } } /* * If the function wasn't found or was out-of-date, we have to compile it. */ if (!function_valid) { /* * Calculate hashkey if we didn't already; we'll need it to store the * completed function. */ if (!hashkey_valid) compute_function_hashkey(fcinfo, procStruct, &hashkey, cacheEntrySize, includeResultType, forValidator); /* * Create the new function struct, if not done already. The function * cache entry will be kept for the life of the backend, so put it in * TopMemoryContext. */ Assert(cacheEntrySize >= sizeof(CachedFunction)); if (function == NULL) { function = (CachedFunction *) MemoryContextAllocZero(TopMemoryContext, cacheEntrySize); new_function = true; } else { /* re-using a previously existing struct, so clear it out */ memset(function, 0, cacheEntrySize); } /* * However, if function compilation fails, we'd like not to leak the * function struct, so use a PG_TRY block to prevent that. (It's up * to the compile callback function to avoid its own internal leakage * in such cases.) Unfortunately, freeing the struct is only safe if * we just allocated it: otherwise there are probably fn_extra * pointers to it. */ PG_TRY(); { /* * Do the hard, language-specific part. */ ccallback(fcinfo, procTup, &hashkey, function, forValidator); } PG_CATCH(); { if (new_function) pfree(function); PG_RE_THROW(); } PG_END_TRY(); /* * Fill in the CachedFunction part. (We do this last to prevent the * function from looking valid before it's fully built.) fn_hashkey * will be set by cfunc_hashtable_insert; use_count remains zero. */ function->fn_xmin = HeapTupleHeaderGetRawXmin(procTup->t_data); function->fn_tid = procTup->t_self; function->dcallback = dcallback; /* * Add the completed struct to the hash table. */ cfunc_hashtable_insert(function, &hashkey); } ReleaseSysCache(procTup); /* * Finally return the compiled function */ return function; }