/*-------------------------------------------------------------------------
 *
 * 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-2026, 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)
	{
		/*
		 * Protect against overrun of fixed-size hashkey->argtypes array. This
		 * also protects later code in places such as PL/pgSQL. Ordinarily the
		 * parser would have checked this long since, but it's possible that
		 * we are looking at a pg_proc entry that was made by a server
		 * executable with a different value of FUNC_MAX_ARGS.
		 */
		if (procStruct->pronargs > FUNC_MAX_ARGS)
			ereport(ERROR,
					(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
					 errmsg_plural("cannot pass more than %d argument to a function",
								   "cannot pass more than %d arguments to a function",
								   FUNC_MAX_ARGS,
								   FUNC_MAX_ARGS)));
		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;
}
