funccache.c File Reference

#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"

Include dependency graph for funccache.c:

Go to the source code of this file.

Data Structures
struct	CachedFunctionHashEntry

Macros
#define	FUNCS_PER_USER   128 /* initial table size */

Typedefs
typedef struct CachedFunctionHashEntry	CachedFunctionHashEntry

Functions
static uint32	cfunc_hash (const void *key, Size keysize)
static int	cfunc_match (const void *key1, const void *key2, Size keysize)
static void	cfunc_hashtable_init (void)
static CachedFunction *	cfunc_hashtable_lookup (CachedFunctionHashKey *func_key)
static void	cfunc_hashtable_insert (CachedFunction *function, CachedFunctionHashKey *func_key)
static void	cfunc_hashtable_delete (CachedFunction *function)
static void	compute_function_hashkey (FunctionCallInfo fcinfo, Form_pg_proc procStruct, CachedFunctionHashKey *hashkey, 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)
static void	delete_function (CachedFunction *func)
CachedFunction *	cached_function_compile (FunctionCallInfo fcinfo, CachedFunction *function, CachedFunctionCompileCallback ccallback, CachedFunctionDeleteCallback dcallback, Size cacheEntrySize, bool includeResultType, bool forValidator)

Variables
static HTAB *	cfunc_hashtable = NULL

Macro Definition Documentation

FUNCS_PER_USER

#define FUNCS_PER_USER   128 /* initial table size */

Definition at line 47 of file funccache.c.

Typedef Documentation

CachedFunctionHashEntry

typedef struct CachedFunctionHashEntry CachedFunctionHashEntry

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, fb(), 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(), and TopMemoryContext.

Referenced by init_sql_fcache(), and plpgsql_compile().

cfunc_hash()

static uint32 cfunc_hash ( const void *  key, Size  keysize  )

static

Definition at line 85 of file funccache.c.

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

References CachedFunctionHashKey::argtypes, Assert, CachedFunctionHashKey::callResultType, DatumGetUInt32(), fb(), hash_any(), hash_combine(), hashRowType(), and CachedFunctionHashKey::nargs.

Referenced by cfunc_hashtable_init().

cfunc_hashtable_delete()

static void cfunc_hashtable_delete ( CachedFunction *  function )

static

Definition at line 207 of file funccache.c.

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

References cfunc_hashtable, elog, fb(), FreeTupleDesc(), function, HASH_REMOVE, hash_search(), and WARNING.

Referenced by delete_function().

cfunc_hashtable_init()

static void cfunc_hashtable_init ( void  )

static

Definition at line 59 of file funccache.c.

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

References Assert, cfunc_hash(), cfunc_hashtable, cfunc_match(), ctl, fb(), FUNCS_PER_USER, HASH_COMPARE, hash_create(), HASH_ELEM, and HASH_FUNCTION.

Referenced by cfunc_hashtable_insert().

cfunc_hashtable_insert()

static void cfunc_hashtable_insert ( CachedFunction *  function, CachedFunctionHashKey *  func_key  )

static

Definition at line 167 of file funccache.c.

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

References cfunc_hashtable, cfunc_hashtable_init(), CreateTupleDescCopy(), elog, fb(), function, HASH_ENTER, hash_search(), MemoryContextSwitchTo(), TopMemoryContext, and WARNING.

Referenced by cached_function_compile().

cfunc_hashtable_lookup()

static CachedFunction * cfunc_hashtable_lookup ( CachedFunctionHashKey *  func_key )

static

Definition at line 146 of file funccache.c.

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

References cfunc_hashtable, fb(), CachedFunctionHashEntry::function, HASH_FIND, and hash_search().

Referenced by cached_function_compile().

cfunc_match()

static int cfunc_match ( const void *  key1, const void *  key2, Size  keysize  )

static

Definition at line 109 of file funccache.c.

{
    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 */
}

References Assert, equalRowTypes(), and fb().

Referenced by cfunc_hashtable_init().

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, fb(), get_call_expr_argtype(), i, OidIsValid, proname, and resolve_polymorphic_argtypes().

Referenced by compute_function_hashkey(), and plpgsql_compile_callback().

compute_function_hashkey()

static void compute_function_hashkey ( FunctionCallInfo  fcinfo, Form_pg_proc  procStruct, CachedFunctionHashKey *  hashkey, Size  cacheEntrySize, bool  includeResultType, bool  forValidator  )

static

Definition at line 247 of file funccache.c.

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

References CALLED_AS_EVENT_TRIGGER, CALLED_AS_TRIGGER, cfunc_resolve_polymorphic_argtypes(), FunctionCallInfoBaseData::context, fb(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, FmgrInfo::fn_oid, FunctionCallInfoBaseData::fncollation, get_call_result_type(), NameStr, TriggerData::tg_trigger, Trigger::tgoid, TYPEFUNC_COMPOSITE, and TYPEFUNC_COMPOSITE_DOMAIN.

Referenced by cached_function_compile().

delete_function()

static void delete_function ( CachedFunction *  func )

static

Definition at line 433 of file funccache.c.

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

References cfunc_hashtable_delete(), CachedFunction::dcallback, fb(), and CachedFunction::use_count.

Referenced by cached_function_compile().

Variable Documentation

cfunc_hashtable

HTAB* cfunc_hashtable = NULL

static

Definition at line 39 of file funccache.c.

Referenced by cfunc_hashtable_delete(), cfunc_hashtable_init(), cfunc_hashtable_insert(), and cfunc_hashtable_lookup().