functions.h File Reference

#include "nodes/execnodes.h"
#include "tcop/dest.h"

Include dependency graph for functions.h:

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

Go to the source code of this file.

Data Structures
struct	SQLFunctionParseInfo

Typedefs
typedef struct SQLFunctionParseInfo	SQLFunctionParseInfo
typedef SQLFunctionParseInfo *	SQLFunctionParseInfoPtr

Functions
Datum	fmgr_sql (PG_FUNCTION_ARGS)
SQLFunctionParseInfoPtr	prepare_sql_fn_parse_info (HeapTuple procedureTuple, Node *call_expr, Oid inputCollation)
void	sql_fn_parser_setup (struct ParseState *pstate, SQLFunctionParseInfoPtr pinfo)
void	check_sql_fn_statements (List *queryTreeLists)
bool	check_sql_fn_retval (List *queryTreeLists, Oid rettype, TupleDesc rettupdesc, char prokind, bool insertDroppedCols)
DestReceiver *	CreateSQLFunctionDestReceiver (void)

Typedef Documentation

SQLFunctionParseInfo

typedef struct SQLFunctionParseInfo SQLFunctionParseInfo

SQLFunctionParseInfoPtr

typedef SQLFunctionParseInfo* SQLFunctionParseInfoPtr

Definition at line 35 of file functions.h.

Function Documentation

check_sql_fn_retval()

bool check_sql_fn_retval	(	List *	queryTreeLists,
		Oid	rettype,
		TupleDesc	rettupdesc,
		char	prokind,
		bool	insertDroppedCols
	)

Definition at line 2116 of file functions.c.

{
    List       *queryTreeList;
 
    /*
     * We consider only the last sublist of Query nodes, so that only the last
     * original statement is a candidate to produce the result.  This is a
     * change from pre-v18 versions, which would back up to the last statement
     * that includes a canSetTag query, thus ignoring any ending statement(s)
     * that rewrite to DO INSTEAD NOTHING.  That behavior was undocumented and
     * there seems no good reason for it, except that it was an artifact of
     * the original coding.
     *
     * If the function body is completely empty, handle that the same as if
     * the last query had rewritten to nothing.
     */
    if (queryTreeLists != NIL)
        queryTreeList = llast_node(List, queryTreeLists);
    else
        queryTreeList = NIL;
 
    return check_sql_stmt_retval(queryTreeList,
                                 rettype, rettupdesc,
                                 prokind, insertDroppedCols);
}

References check_sql_stmt_retval(), llast_node, and NIL.

Referenced by fmgr_sql_validator(), inline_function(), and inline_set_returning_function().

check_sql_fn_statements()

void check_sql_fn_statements

(

List *

queryTreeLists

)

Definition at line 2035 of file functions.c.

{
    ListCell   *lc;
 
    /* We are given a list of sublists of Queries */
    foreach(lc, queryTreeLists)
    {
        List       *sublist = lfirst_node(List, lc);
 
        check_sql_fn_statement(sublist);
    }
}

References check_sql_fn_statement(), and lfirst_node.

Referenced by fmgr_sql_validator().

CreateSQLFunctionDestReceiver()

DestReceiver * CreateSQLFunctionDestReceiver

(

void

)

Definition at line 2617 of file functions.c.

{
    DR_sqlfunction *self = (DR_sqlfunction *) palloc0(sizeof(DR_sqlfunction));
 
    self->pub.receiveSlot = sqlfunction_receive;
    self->pub.rStartup = sqlfunction_startup;
    self->pub.rShutdown = sqlfunction_shutdown;
    self->pub.rDestroy = sqlfunction_destroy;
    self->pub.mydest = DestSQLFunction;
 
    /* private fields will be set by postquel_start */
 
    return (DestReceiver *) self;
}

References DestSQLFunction, _DestReceiver::mydest, palloc0(), DR_sqlfunction::pub, _DestReceiver::rDestroy, _DestReceiver::receiveSlot, _DestReceiver::rShutdown, _DestReceiver::rStartup, sqlfunction_destroy(), sqlfunction_receive(), sqlfunction_shutdown(), and sqlfunction_startup().

Referenced by CreateDestReceiver().

fmgr_sql()

Datum fmgr_sql

(

PG_FUNCTION_ARGS

)

Definition at line 1576 of file functions.c.

{
    SQLFunctionCachePtr fcache;
    ErrorContextCallback sqlerrcontext;
    MemoryContext tscontext;
    bool        randomAccess;
    bool        lazyEvalOK;
    bool        pushed_snapshot;
    execution_state *es;
    TupleTableSlot *slot;
    Datum       result;
 
    /* Check call context */
    if (fcinfo->flinfo->fn_retset)
    {
        ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
        /*
         * For simplicity, we require callers to support both set eval modes.
         * There are cases where we must use one or must use the other, and
         * it's not really worthwhile to postpone the check till we know. But
         * note we do not require caller to provide an expectedDesc.
         */
        if (!rsi || !IsA(rsi, ReturnSetInfo) ||
            (rsi->allowedModes & SFRM_ValuePerCall) == 0 ||
            (rsi->allowedModes & SFRM_Materialize) == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("set-valued function called in context that cannot accept a set")));
        randomAccess = rsi->allowedModes & SFRM_Materialize_Random;
        lazyEvalOK = !(rsi->allowedModes & SFRM_Materialize_Preferred);
        /* tuplestore, if used, must have query lifespan */
        tscontext = rsi->econtext->ecxt_per_query_memory;
    }
    else
    {
        randomAccess = false;
        lazyEvalOK = true;
        /* we won't need a tuplestore */
        tscontext = NULL;
    }
 
    /*
     * Initialize fcache if starting a fresh execution.
     */
    fcache = init_sql_fcache(fcinfo, lazyEvalOK);
 
    /* Mark fcache as active */
    fcache->active = true;
 
    /* Remember info that we might need later to construct tuplestore */
    fcache->tscontext = tscontext;
    fcache->randomAccess = randomAccess;
 
    /*
     * Now we can set up error traceback support for ereport()
     */
    sqlerrcontext.callback = sql_exec_error_callback;
    sqlerrcontext.arg = fcache;
    sqlerrcontext.previous = error_context_stack;
    error_context_stack = &sqlerrcontext;
 
    /*
     * Find first unfinished execution_state.  If none, advance to the next
     * query in function.
     */
    do
    {
        es = fcache->eslist;
        while (es && es->status == F_EXEC_DONE)
            es = es->next;
        if (es)
            break;
    } while (init_execution_state(fcache));
 
    /*
     * Execute each command in the function one after another until we either
     * run out of commands or get a result row from a lazily-evaluated SELECT.
     *
     * Notes about snapshot management:
     *
     * In a read-only function, we just use the surrounding query's snapshot.
     *
     * In a non-read-only function, we rely on the fact that we'll never
     * suspend execution between queries of the function: the only reason to
     * suspend execution before completion is if we are returning a row from a
     * lazily-evaluated SELECT.  So, when first entering this loop, we'll
     * either start a new query (and push a fresh snapshot) or re-establish
     * the active snapshot from the existing query descriptor.  If we need to
     * start a new query in a subsequent execution of the loop, either we need
     * a fresh snapshot (and pushed_snapshot is false) or the existing
     * snapshot is on the active stack and we can just bump its command ID.
     */
    pushed_snapshot = false;
    while (es)
    {
        bool        completed;
 
        if (es->status == F_EXEC_START)
        {
            /*
             * If not read-only, be sure to advance the command counter for
             * each command, so that all work to date in this transaction is
             * visible.  Take a new snapshot if we don't have one yet,
             * otherwise just bump the command ID in the existing snapshot.
             */
            if (!fcache->func->readonly_func)
            {
                CommandCounterIncrement();
                if (!pushed_snapshot)
                {
                    PushActiveSnapshot(GetTransactionSnapshot());
                    pushed_snapshot = true;
                }
                else
                    UpdateActiveSnapshotCommandId();
            }
 
            postquel_start(es, fcache);
        }
        else if (!fcache->func->readonly_func && !pushed_snapshot)
        {
            /* Re-establish active snapshot when re-entering function */
            PushActiveSnapshot(es->qd->snapshot);
            pushed_snapshot = true;
        }
 
        completed = postquel_getnext(es, fcache);
 
        /*
         * If we ran the command to completion, we can shut it down now. Any
         * row(s) we need to return are safely stashed in the result slot or
         * tuplestore, and we want to be sure that, for example, AFTER
         * triggers get fired before we return anything.  Also, if the
         * function doesn't return set, we can shut it down anyway because it
         * must be a SELECT and we don't care about fetching any more result
         * rows.
         */
        if (completed || !fcache->func->returnsSet)
            postquel_end(es, fcache);
 
        /*
         * Break from loop if we didn't shut down (implying we got a
         * lazily-evaluated row).  Otherwise we'll press on till the whole
         * function is done, relying on the tuplestore to keep hold of the
         * data to eventually be returned.  This is necessary since an
         * INSERT/UPDATE/DELETE RETURNING that sets the result might be
         * followed by additional rule-inserted commands, and we want to
         * finish doing all those commands before we return anything.
         */
        if (es->status != F_EXEC_DONE)
            break;
 
        /*
         * Advance to next execution_state, and perhaps next query.
         */
        es = es->next;
        while (!es)
        {
            /*
             * Flush the current snapshot so that we will take a new one for
             * the new query list.  This ensures that new snaps are taken at
             * original-query boundaries, matching the behavior of interactive
             * execution.
             */
            if (pushed_snapshot)
            {
                PopActiveSnapshot();
                pushed_snapshot = false;
            }
 
            if (!init_execution_state(fcache))
                break;          /* end of function */
 
            es = fcache->eslist;
        }
    }
 
    /*
     * The result slot or tuplestore now contains whatever row(s) we are
     * supposed to return.
     */
    if (fcache->func->returnsSet)
    {
        ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
 
        if (es)
        {
            /*
             * If we stopped short of being done, we must have a lazy-eval
             * row.
             */
            Assert(es->lazyEval);
            /* The junkfilter's result slot contains the query result tuple */
            Assert(fcache->junkFilter);
            slot = fcache->junkFilter->jf_resultSlot;
            Assert(!TTS_EMPTY(slot));
            /* Extract the result as a datum, and copy out from the slot */
            result = postquel_get_single_result(slot, fcinfo, fcache);
 
            /*
             * Let caller know we're not finished.
             */
            rsi->isDone = ExprMultipleResult;
 
            /*
             * Ensure we will get shut down cleanly if the exprcontext is not
             * run to completion.
             */
            if (!fcache->shutdown_reg)
            {
                RegisterExprContextCallback(rsi->econtext,
                                            ShutdownSQLFunction,
                                            PointerGetDatum(fcache));
                fcache->shutdown_reg = true;
            }
        }
        else if (fcache->lazyEval)
        {
            /*
             * We are done with a lazy evaluation.  Let caller know we're
             * finished.
             */
            rsi->isDone = ExprEndResult;
 
            fcinfo->isnull = true;
            result = (Datum) 0;
 
            /* Deregister shutdown callback, if we made one */
            if (fcache->shutdown_reg)
            {
                UnregisterExprContextCallback(rsi->econtext,
                                              ShutdownSQLFunction,
                                              PointerGetDatum(fcache));
                fcache->shutdown_reg = false;
            }
        }
        else
        {
            /*
             * We are done with a non-lazy evaluation.  Return whatever is in
             * the tuplestore.  (It is now caller's responsibility to free the
             * tuplestore when done.)
             *
             * Note an edge case: we could get here without having made a
             * tuplestore if the function is declared to return SETOF VOID.
             * ExecMakeTableFunctionResult will cope with null setResult.
             */
            Assert(fcache->tstore || fcache->func->rettype == VOIDOID);
            rsi->returnMode = SFRM_Materialize;
            rsi->setResult = fcache->tstore;
            fcache->tstore = NULL;
            /* must copy desc because execSRF.c will free it */
            if (fcache->junkFilter)
                rsi->setDesc = CreateTupleDescCopy(fcache->junkFilter->jf_cleanTupType);
 
            fcinfo->isnull = true;
            result = (Datum) 0;
 
            /* Deregister shutdown callback, if we made one */
            if (fcache->shutdown_reg)
            {
                UnregisterExprContextCallback(rsi->econtext,
                                              ShutdownSQLFunction,
                                              PointerGetDatum(fcache));
                fcache->shutdown_reg = false;
            }
        }
    }
    else
    {
        /*
         * Non-set function.  If we got a row, return it; else return NULL.
         */
        if (fcache->junkFilter)
        {
            /* The junkfilter's result slot contains the query result tuple */
            slot = fcache->junkFilter->jf_resultSlot;
            if (!TTS_EMPTY(slot))
                result = postquel_get_single_result(slot, fcinfo, fcache);
            else
            {
                fcinfo->isnull = true;
                result = (Datum) 0;
            }
        }
        else
        {
            /* Should only get here for VOID functions and procedures */
            Assert(fcache->func->rettype == VOIDOID);
            fcinfo->isnull = true;
            result = (Datum) 0;
        }
    }
 
    /* Pop snapshot if we have pushed one */
    if (pushed_snapshot)
        PopActiveSnapshot();
 
    /*
     * If we've gone through every command in the function, we are done. Reset
     * state to start over again on next call.
     */
    if (es == NULL)
        fcache->eslist = NULL;
 
    /* Mark fcache as inactive */
    fcache->active = false;
 
    error_context_stack = sqlerrcontext.previous;
 
    return result;
}

References SQLFunctionCache::active, ReturnSetInfo::allowedModes, ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, CommandCounterIncrement(), CreateTupleDescCopy(), ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ereport, errcode(), errmsg(), ERROR, error_context_stack, SQLFunctionCache::eslist, ExprEndResult, ExprMultipleResult, F_EXEC_DONE, F_EXEC_START, SQLFunctionCache::func, GetTransactionSnapshot(), if(), init_execution_state(), init_sql_fcache(), IsA, ReturnSetInfo::isDone, JunkFilter::jf_cleanTupType, JunkFilter::jf_resultSlot, SQLFunctionCache::junkFilter, execution_state::lazyEval, SQLFunctionCache::lazyEval, execution_state::next, PointerGetDatum(), PopActiveSnapshot(), postquel_end(), postquel_get_single_result(), postquel_getnext(), postquel_start(), ErrorContextCallback::previous, PushActiveSnapshot(), execution_state::qd, SQLFunctionCache::randomAccess, SQLFunctionHashEntry::readonly_func, RegisterExprContextCallback(), SQLFunctionHashEntry::rettype, ReturnSetInfo::returnMode, SQLFunctionHashEntry::returnsSet, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Preferred, SFRM_Materialize_Random, SFRM_ValuePerCall, SQLFunctionCache::shutdown_reg, ShutdownSQLFunction(), QueryDesc::snapshot, sql_exec_error_callback(), execution_state::status, SQLFunctionCache::tscontext, SQLFunctionCache::tstore, TTS_EMPTY, UnregisterExprContextCallback(), and UpdateActiveSnapshotCommandId().

Referenced by fmgr_info_cxt_security().

prepare_sql_fn_parse_info()

SQLFunctionParseInfoPtr prepare_sql_fn_parse_info	(	HeapTuple	procedureTuple,
		Node *	call_expr,
		Oid	inputCollation
	)

Definition at line 251 of file functions.c.

{
    SQLFunctionParseInfoPtr pinfo;
    Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
    int         nargs;
 
    pinfo = (SQLFunctionParseInfoPtr) palloc0(sizeof(SQLFunctionParseInfo));
 
    /* Function's name (only) can be used to qualify argument names */
    pinfo->fname = pstrdup(NameStr(procedureStruct->proname));
 
    /* Save the function's input collation */
    pinfo->collation = inputCollation;
 
    /*
     * Copy input argument types from the pg_proc entry, then resolve any
     * polymorphic types.
     */
    pinfo->nargs = nargs = procedureStruct->pronargs;
    if (nargs > 0)
    {
        Oid        *argOidVect;
        int         argnum;
 
        argOidVect = (Oid *) palloc(nargs * sizeof(Oid));
        memcpy(argOidVect,
               procedureStruct->proargtypes.values,
               nargs * sizeof(Oid));
 
        for (argnum = 0; argnum < nargs; argnum++)
        {
            Oid         argtype = argOidVect[argnum];
 
            if (IsPolymorphicType(argtype))
            {
                argtype = get_call_expr_argtype(call_expr, argnum);
                if (argtype == InvalidOid)
                    ereport(ERROR,
                            (errcode(ERRCODE_DATATYPE_MISMATCH),
                             errmsg("could not determine actual type of argument declared %s",
                                    format_type_be(argOidVect[argnum]))));
                argOidVect[argnum] = argtype;
            }
        }
 
        pinfo->argtypes = argOidVect;
    }
 
    /*
     * Collect names of arguments, too, if any
     */
    if (nargs > 0)
    {
        Datum       proargnames;
        Datum       proargmodes;
        int         n_arg_names;
        bool        isNull;
 
        proargnames = SysCacheGetAttr(PROCNAMEARGSNSP, procedureTuple,
                                      Anum_pg_proc_proargnames,
                                      &isNull);
        if (isNull)
            proargnames = PointerGetDatum(NULL);    /* just to be sure */
 
        proargmodes = SysCacheGetAttr(PROCNAMEARGSNSP, procedureTuple,
                                      Anum_pg_proc_proargmodes,
                                      &isNull);
        if (isNull)
            proargmodes = PointerGetDatum(NULL);    /* just to be sure */
 
        n_arg_names = get_func_input_arg_names(proargnames, proargmodes,
                                               &pinfo->argnames);
 
        /* Paranoia: ignore the result if too few array entries */
        if (n_arg_names < nargs)
            pinfo->argnames = NULL;
    }
    else
        pinfo->argnames = NULL;
 
    return pinfo;
}

References SQLFunctionParseInfo::argnames, SQLFunctionParseInfo::argtypes, SQLFunctionParseInfo::collation, ereport, errcode(), errmsg(), ERROR, SQLFunctionParseInfo::fname, format_type_be(), get_call_expr_argtype(), get_func_input_arg_names(), GETSTRUCT(), InvalidOid, NameStr, SQLFunctionParseInfo::nargs, palloc(), palloc0(), PointerGetDatum(), pstrdup(), and SysCacheGetAttr().

Referenced by fmgr_sql_validator(), inline_function(), inline_set_returning_function(), and sql_compile_callback().

sql_fn_parser_setup()

void sql_fn_parser_setup	(	struct ParseState *	pstate,
		SQLFunctionParseInfoPtr	pinfo
	)

Definition at line 340 of file functions.c.

{
    pstate->p_pre_columnref_hook = NULL;
    pstate->p_post_columnref_hook = sql_fn_post_column_ref;
    pstate->p_paramref_hook = sql_fn_param_ref;
    /* no need to use p_coerce_param_hook */
    pstate->p_ref_hook_state = pinfo;
}

References ParseState::p_paramref_hook, ParseState::p_post_columnref_hook, ParseState::p_pre_columnref_hook, ParseState::p_ref_hook_state, sql_fn_param_ref(), and sql_fn_post_column_ref().

Referenced by fmgr_sql_validator(), inline_function(), inline_set_returning_function(), interpret_AS_clause(), and prepare_next_query().