1 files changed, 134 insertions, 0 deletions
diff --git a/src/include/utils/funccache.h b/src/include/utils/funccache.h
new file mode 100644
index 00000000000..e0112ebfa11
--- /dev/null
+++ b/src/include/utils/funccache.h
@@ -0,0 +1,134 @@
+/*-------------------------------------------------------------------------
+ *
+ * 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 */