funccache.h File Reference

#include "access/htup_details.h"
#include "fmgr.h"
#include "storage/itemptr.h"

Include dependency graph for funccache.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	CachedFunctionHashKey
struct	CachedFunction

Typedefs
typedef void(*	CachedFunctionCompileCallback) (FunctionCallInfo fcinfo, HeapTuple procTup, const struct CachedFunctionHashKey *hashkey, struct CachedFunction *function, bool forValidator)
typedef void(*	CachedFunctionDeleteCallback) (struct CachedFunction *cfunc)
typedef struct CachedFunctionHashKey	CachedFunctionHashKey
typedef struct CachedFunction	CachedFunction

Functions
CachedFunction *	cached_function_compile (FunctionCallInfo fcinfo, CachedFunction *function, CachedFunctionCompileCallback ccallback, CachedFunctionDeleteCallback dcallback, Size cacheEntrySize, bool includeResultType, bool forValidator)
void	cfunc_resolve_polymorphic_argtypes (int numargs, Oid *argtypes, char *argmodes, Node *call_expr, bool forValidator, const char *proname)

Typedef Documentation

CachedFunction

typedef struct CachedFunction CachedFunction

CachedFunctionCompileCallback

typedef void(* CachedFunctionCompileCallback) (FunctionCallInfo fcinfo, HeapTuple procTup, const struct CachedFunctionHashKey *hashkey, struct CachedFunction *function, bool forValidator)

Definition at line 35 of file funccache.h.

CachedFunctionDeleteCallback

typedef void(* CachedFunctionDeleteCallback) (struct CachedFunction *cfunc)

Definition at line 45 of file funccache.h.

CachedFunctionHashKey

typedef struct CachedFunctionHashKey CachedFunctionHashKey

Function Documentation

cached_function_compile()

CachedFunction * cached_function_compile	(	FunctionCallInfo	fcinfo,
		CachedFunction *	function,
		CachedFunctionCompileCallback	ccallback,
		CachedFunctionDeleteCallback	dcallback,
		Size	cacheEntrySize,
		bool	includeResultType,
		bool	forValidator
	)

Definition at line 480 of file funccache.c.

{
    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;
}

References Assert(), cfunc_hashtable_insert(), cfunc_hashtable_lookup(), compute_function_hashkey(), delete_function(), elog, ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_oid, function, GETSTRUCT(), HeapTupleHeaderGetRawXmin(), HeapTupleIsValid, ItemPointerEquals(), MemoryContextAllocZero(), ObjectIdGetDatum(), pfree(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, ReleaseSysCache(), SearchSysCache1(), HeapTupleData::t_data, HeapTupleData::t_self, and TopMemoryContext.

Referenced by init_sql_fcache(), and plpgsql_compile().

cfunc_resolve_polymorphic_argtypes()

void cfunc_resolve_polymorphic_argtypes	(	int	numargs,
		Oid *	argtypes,
		char *	argmodes,
		Node *	call_expr,
		bool	forValidator,
		const char *	proname
	)

Definition at line 348 of file funccache.c.

{
    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;
            }
        }
    }
}

References ereport, errcode(), errmsg(), ERROR, get_call_expr_argtype(), i, OidIsValid, proname, and resolve_polymorphic_argtypes().

Referenced by compute_function_hashkey(), and plpgsql_compile_callback().