/*------------------------------------------------------------------------- * * funccache.h * Function cache definitions. * * See funccache.c for comments. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * src/include/utils/funccache.h * *------------------------------------------------------------------------- */ #ifndef FUNCCACHE_H #define FUNCCACHE_H #include "access/htup_details.h" #include "fmgr.h" #include "storage/itemptr.h" struct CachedFunctionHashKey; /* forward references */ struct CachedFunction; /* * Callback that cached_function_compile() invokes when it's necessary to * compile a cached function. The callback must fill in *function (except * for the fields of struct CachedFunction), or throw an error if trouble. * fcinfo: current call information * procTup: function's pg_proc row from catcache * hashkey: hash key that will be used for the function * function: pre-zeroed workspace, of size passed to cached_function_compile() * forValidator: passed through from cached_function_compile() */ typedef void (*CachedFunctionCompileCallback) (FunctionCallInfo fcinfo, HeapTuple procTup, const struct CachedFunctionHashKey *hashkey, struct CachedFunction *function, bool forValidator); /* * Callback called when discarding a cache entry. Free any free-able * subsidiary data of cfunc, but not the struct CachedFunction itself. */ typedef void (*CachedFunctionDeleteCallback) (struct CachedFunction *cfunc); /* * Hash lookup key for functions. This must account for all aspects * of a specific call that might lead to different data types or * collations being used within the function. */ typedef struct CachedFunctionHashKey { Oid funcOid; bool isTrigger; /* true if called as a DML trigger */ bool isEventTrigger; /* true if called as an event trigger */ /* be careful that pad bytes in this struct get zeroed! */ /* * We include the language-specific size of the function's cache entry in * the cache key. This covers the case where CREATE OR REPLACE FUNCTION * is used to change the implementation language, and the new language * also uses funccache.c but needs a different-sized cache entry. */ Size cacheEntrySize; /* * For a trigger function, the OID of the trigger is part of the hash key * --- we want to compile the trigger function separately for each trigger * it is used with, in case the rowtype or transition table names are * different. Zero if not called as a DML trigger. */ Oid trigOid; /* * We must include the input collation as part of the hash key too, * because we have to generate different plans (with different Param * collations) for different collation settings. */ Oid inputCollation; /* Number of arguments (counting input arguments only, ie pronargs) */ int nargs; /* If you change anything below here, fix hashing code in funccache.c! */ /* * If relevant, the result descriptor for a function returning composite. */ TupleDesc callResultType; /* * Input argument types, with any polymorphic types resolved to actual * types. Only the first nargs entries are valid. */ Oid argtypes[FUNC_MAX_ARGS]; } CachedFunctionHashKey; /* * Representation of a compiled function. This struct contains just the * fields that funccache.c needs to deal with. It will typically be * embedded in a larger struct containing function-language-specific data. */ typedef struct CachedFunction { /* back-link to hashtable entry, or NULL if not in hash table */ CachedFunctionHashKey *fn_hashkey; /* xmin and ctid of function's pg_proc row; used to detect invalidation */ TransactionId fn_xmin; ItemPointerData fn_tid; /* deletion callback */ CachedFunctionDeleteCallback dcallback; /* this field changes when the function is used: */ uint64 use_count; } CachedFunction; extern CachedFunction *cached_function_compile(FunctionCallInfo fcinfo, CachedFunction *function, CachedFunctionCompileCallback ccallback, CachedFunctionDeleteCallback dcallback, Size cacheEntrySize, bool includeResultType, bool forValidator); extern void cfunc_resolve_polymorphic_argtypes(int numargs, Oid *argtypes, char *argmodes, Node *call_expr, bool forValidator, const char *proname); #endif /* FUNCCACHE_H */