#include "postgres.h"
#include "access/htup_details.h"
#include "access/xact.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "executor/functions.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "parser/parse_func.h"
#include "storage/proc.h"
#include "tcop/utility.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for functions.c:

Data Structures
struct	DR_sqlfunction

struct	execution_state

struct	SQLFunctionCache

struct	SQLFunctionParseInfo

Typedefs
typedef struct execution_state	execution_state

typedef SQLFunctionCache *	SQLFunctionCachePtr

typedef struct SQLFunctionParseInfo	SQLFunctionParseInfo

Enumerations
enum	ExecStatus { F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE }

Functions
static Node *	sql_fn_param_ref (ParseState pstate, ParamRef pref)

static Node *	sql_fn_post_column_ref (ParseState pstate, ColumnRef cref, Node *var)

static Node *	sql_fn_make_param (SQLFunctionParseInfoPtr pinfo, int paramno, int location)

static Node *	sql_fn_resolve_param_name (SQLFunctionParseInfoPtr pinfo, const char *paramname, int location)

static List *	init_execution_state (List *queryTree_list, SQLFunctionCachePtr fcache, bool lazyEvalOK)

static void	init_sql_fcache (FunctionCallInfo fcinfo, Oid collation, bool lazyEvalOK)

static void	postquel_start (execution_state *es, SQLFunctionCachePtr fcache)

static bool	postquel_getnext (execution_state *es, SQLFunctionCachePtr fcache)

static void	postquel_end (execution_state *es)

static void	postquel_sub_params (SQLFunctionCachePtr fcache, FunctionCallInfo fcinfo)

static Datum	postquel_get_single_result (TupleTableSlot *slot, FunctionCallInfo fcinfo, SQLFunctionCachePtr fcache, MemoryContext resultcontext)

static void	sql_exec_error_callback (void *arg)

static void	ShutdownSQLFunction (Datum arg)

static bool	coerce_fn_result_column (TargetEntry src_tle, Oid res_type, int32 res_typmod, bool tlist_is_modifiable, List upper_tlist, bool upper_tlist_nontrivial)

static void	sqlfunction_startup (DestReceiver *self, int operation, TupleDesc typeinfo)

static bool	sqlfunction_receive (TupleTableSlot slot, DestReceiver self)

static void	sqlfunction_shutdown (DestReceiver *self)

static void	sqlfunction_destroy (DestReceiver *self)

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

void	sql_fn_parser_setup (struct ParseState *pstate, SQLFunctionParseInfoPtr pinfo)

Datum	fmgr_sql (PG_FUNCTION_ARGS)

void	check_sql_fn_statements (List *queryTreeList)

bool	check_sql_fn_retval (List queryTreeList, Oid rettype, TupleDesc rettupdesc, bool insertDroppedCols, List *resultTargetList)

DestReceiver *	CreateSQLFunctionDestReceiver (void)

Typedef Documentation

◆ execution_state

typedef struct execution_state execution_state

◆ SQLFunctionCachePtr

typedef SQLFunctionCache* SQLFunctionCachePtr

Definition at line 128 of file functions.c.

◆ SQLFunctionParseInfo

typedef struct SQLFunctionParseInfo SQLFunctionParseInfo

Enumeration Type Documentation

◆ ExecStatus

enum ExecStatus

Enumerator
F_EXEC_START
F_EXEC_RUN
F_EXEC_DONE

Definition at line 58 of file functions.c.

 {
     F_EXEC_START, F_EXEC_RUN, F_EXEC_DONE
 } ExecStatus;

Function Documentation

◆ check_sql_fn_retval()

bool check_sql_fn_retval	(	List *	queryTreeList,
		Oid	rettype,
		TupleDesc	rettupdesc,
		bool	insertDroppedCols,
		List **	resultTargetList
	)

Definition at line 1589 of file functions.c.

References RangeTblEntry::alias, Assert, AssertArg, Query::canSetTag, CMD_DELETE, CMD_INSERT, CMD_SELECT, CMD_UPDATE, coerce_fn_result_column(), Query::commandType, RangeTblEntry::eref, ereport, errcode(), errdetail(), errmsg(), ERROR, ExecCleanTargetListLength(), TargetEntry::expr, exprType(), format_type_be(), get_typtype(), RangeTblEntry::inFromCl, RangeTblEntry::inh, InvalidOid, Query::jointree, lappend(), RangeTblEntry::lateral, lfirst, lfirst_node, linitial, list_length(), list_make1, makeAlias(), makeConst(), makeFromExpr(), makeNode, makeString(), makeTargetEntry(), TupleDescData::natts, NIL, parse(), Query::querySource, TargetEntry::resjunk, TargetEntry::resname, Query::returningList, Query::rtable, RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblRef::rtindex, Query::setOperations, RangeTblEntry::subquery, Query::targetList, and TupleDescAttr.

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

 {
     bool        is_tuple_result = false;
     Query      *parse;
     ListCell   *parse_cell;
     List       *tlist;
     int         tlistlen;
     bool        tlist_is_modifiable;
     char        fn_typtype;
     List       *upper_tlist = NIL;
     bool        upper_tlist_nontrivial = false;
     ListCell   *lc;
 
     /* Caller must have resolved any polymorphism */
     AssertArg(!IsPolymorphicType(rettype));
 
     if (resultTargetList)
         *resultTargetList = NIL;    /* initialize in case of VOID result */
 
     /*
      * If it's declared to return VOID, we don't care what's in the function.
      * (This takes care of the procedure case, as well.)
      */
     if (rettype == VOIDOID)
         return false;
 
     /*
      * Find the last canSetTag query in the list.  This isn't necessarily the
      * last parsetree, because rule rewriting can insert queries after what
      * the user wrote.
      */
     parse = NULL;
     parse_cell = NULL;
     foreach(lc, queryTreeList)
     {
         Query      *q = lfirst_node(Query, lc);
 
         if (q->canSetTag)
         {
             parse = q;
             parse_cell = lc;
         }
     }
 
     /*
      * If it's a plain SELECT, it returns whatever the targetlist says.
      * Otherwise, if it's INSERT/UPDATE/DELETE with RETURNING, it returns
      * that. Otherwise, the function return type must be VOID.
      *
      * Note: eventually replace this test with QueryReturnsTuples?  We'd need
      * a more general method of determining the output type, though.  Also, it
      * seems too dangerous to consider FETCH or EXECUTE as returning a
      * determinable rowtype, since they depend on relatively short-lived
      * entities.
      */
     if (parse &&
         parse->commandType == CMD_SELECT)
     {
         tlist = parse->targetList;
         /* tlist is modifiable unless it's a dummy in a setop query */
         tlist_is_modifiable = (parse->setOperations == NULL);
     }
     else if (parse &&
              (parse->commandType == CMD_INSERT ||
               parse->commandType == CMD_UPDATE ||
               parse->commandType == CMD_DELETE) &&
              parse->returningList)
     {
         tlist = parse->returningList;
         /* returningList can always be modified */
         tlist_is_modifiable = true;
     }
     else
     {
         /* Empty function body, or last statement is a utility command */
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("return type mismatch in function declared to return %s",
                         format_type_be(rettype)),
                  errdetail("Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING.")));
         return false;           /* keep compiler quiet */
     }
 
     /*
      * OK, check that the targetlist returns something matching the declared
      * type, and modify it if necessary.  If possible, we insert any coercion
      * steps right into the final statement's targetlist.  However, that might
      * risk changes in the statement's semantics --- we can't safely change
      * the output type of a grouping column, for instance.  In such cases we
      * handle coercions by inserting an extra level of Query that effectively
      * just does a projection.
      */
 
     /*
      * Count the non-junk entries in the result targetlist.
      */
     tlistlen = ExecCleanTargetListLength(tlist);
 
     fn_typtype = get_typtype(rettype);
 
     if (fn_typtype == TYPTYPE_BASE ||
         fn_typtype == TYPTYPE_DOMAIN ||
         fn_typtype == TYPTYPE_ENUM ||
         fn_typtype == TYPTYPE_RANGE)
     {
         /*
          * For scalar-type returns, the target list must have exactly one
          * non-junk entry, and its type must be coercible to rettype.
          */
         TargetEntry *tle;
 
         if (tlistlen != 1)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("return type mismatch in function declared to return %s",
                             format_type_be(rettype)),
                      errdetail("Final statement must return exactly one column.")));
 
         /* We assume here that non-junk TLEs must come first in tlists */
         tle = (TargetEntry *) linitial(tlist);
         Assert(!tle->resjunk);
 
         if (!coerce_fn_result_column(tle, rettype, -1,
                                      tlist_is_modifiable,
                                      &upper_tlist,
                                      &upper_tlist_nontrivial))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("return type mismatch in function declared to return %s",
                             format_type_be(rettype)),
                      errdetail("Actual return type is %s.",
                                format_type_be(exprType((Node *) tle->expr)))));
     }
     else if (fn_typtype == TYPTYPE_COMPOSITE || rettype == RECORDOID)
     {
         /*
          * Returns a rowtype.
          *
          * Note that we will not consider a domain over composite to be a
          * "rowtype" return type; it goes through the scalar case above.  This
          * is because we only provide column-by-column implicit casting, and
          * will not cast the complete record result.  So the only way to
          * produce a domain-over-composite result is to compute it as an
          * explicit single-column result.  The single-composite-column code
          * path just below could handle such cases, but it won't be reached.
          */
         int         tupnatts;   /* physical number of columns in tuple */
         int         tuplogcols; /* # of nondeleted columns in tuple */
         int         colindex;   /* physical column index */
 
         /*
          * If the target list has one non-junk entry, and that expression has
          * or can be coerced to the declared return type, take it as the
          * result.  This allows, for example, 'SELECT func2()', where func2
          * has the same composite return type as the function that's calling
          * it.  This provision creates some ambiguity --- maybe the expression
          * was meant to be the lone field of the composite result --- but it
          * works well enough as long as we don't get too enthusiastic about
          * inventing coercions from scalar to composite types.
          *
          * XXX Note that if rettype is RECORD and the expression is of a named
          * composite type, or vice versa, this coercion will succeed, whether
          * or not the record type really matches.  For the moment we rely on
          * runtime type checking to catch any discrepancy, but it'd be nice to
          * do better at parse time.
          */
         if (tlistlen == 1)
         {
             TargetEntry *tle = (TargetEntry *) linitial(tlist);
 
             Assert(!tle->resjunk);
             if (coerce_fn_result_column(tle, rettype, -1,
                                         tlist_is_modifiable,
                                         &upper_tlist,
                                         &upper_tlist_nontrivial))
             {
                 /* Note that we're NOT setting is_tuple_result */
                 goto tlist_coercion_finished;
             }
         }
 
         /*
          * If the caller didn't provide an expected tupdesc, we can't do any
          * further checking.  Assume we're returning the whole tuple.
          */
         if (rettupdesc == NULL)
         {
             /* Return tlist if requested */
             if (resultTargetList)
                 *resultTargetList = tlist;
             return true;
         }
 
         /*
          * Verify that the targetlist matches the return tuple type.  We scan
          * the non-resjunk columns, and coerce them if necessary to match the
          * datatypes of the non-deleted attributes.  For deleted attributes,
          * insert NULL result columns if the caller asked for that.
          */
         tupnatts = rettupdesc->natts;
         tuplogcols = 0;         /* we'll count nondeleted cols as we go */
         colindex = 0;
 
         foreach(lc, tlist)
         {
             TargetEntry *tle = (TargetEntry *) lfirst(lc);
             Form_pg_attribute attr;
 
             /* resjunk columns can simply be ignored */
             if (tle->resjunk)
                 continue;
 
             do
             {
                 colindex++;
                 if (colindex > tupnatts)
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                              errmsg("return type mismatch in function declared to return %s",
                                     format_type_be(rettype)),
                              errdetail("Final statement returns too many columns.")));
                 attr = TupleDescAttr(rettupdesc, colindex - 1);
                 if (attr->attisdropped && insertDroppedCols)
                 {
                     Expr       *null_expr;
 
                     /* The type of the null we insert isn't important */
                     null_expr = (Expr *) makeConst(INT4OID,
                                                    -1,
                                                    InvalidOid,
                                                    sizeof(int32),
                                                    (Datum) 0,
                                                    true,    /* isnull */
                                                    true /* byval */ );
                     upper_tlist = lappend(upper_tlist,
                                           makeTargetEntry(null_expr,
                                                           list_length(upper_tlist) + 1,
                                                           NULL,
                                                           false));
                     upper_tlist_nontrivial = true;
                 }
             } while (attr->attisdropped);
             tuplogcols++;
 
             if (!coerce_fn_result_column(tle,
                                          attr->atttypid, attr->atttypmod,
                                          tlist_is_modifiable,
                                          &upper_tlist,
                                          &upper_tlist_nontrivial))
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                          errmsg("return type mismatch in function declared to return %s",
                                 format_type_be(rettype)),
                          errdetail("Final statement returns %s instead of %s at column %d.",
                                    format_type_be(exprType((Node *) tle->expr)),
                                    format_type_be(attr->atttypid),
                                    tuplogcols)));
         }
 
         /* remaining columns in rettupdesc had better all be dropped */
         for (colindex++; colindex <= tupnatts; colindex++)
         {
             if (!TupleDescAttr(rettupdesc, colindex - 1)->attisdropped)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                          errmsg("return type mismatch in function declared to return %s",
                                 format_type_be(rettype)),
                          errdetail("Final statement returns too few columns.")));
             if (insertDroppedCols)
             {
                 Expr       *null_expr;
 
                 /* The type of the null we insert isn't important */
                 null_expr = (Expr *) makeConst(INT4OID,
                                                -1,
                                                InvalidOid,
                                                sizeof(int32),
                                                (Datum) 0,
                                                true,    /* isnull */
                                                true /* byval */ );
                 upper_tlist = lappend(upper_tlist,
                                       makeTargetEntry(null_expr,
                                                       list_length(upper_tlist) + 1,
                                                       NULL,
                                                       false));
                 upper_tlist_nontrivial = true;
             }
         }
 
         /* Report that we are returning entire tuple result */
         is_tuple_result = true;
     }
     else
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("return type %s is not supported for SQL functions",
                         format_type_be(rettype))));
 
 tlist_coercion_finished:
 
     /*
      * If necessary, modify the final Query by injecting an extra Query level
      * that just performs a projection.  (It'd be dubious to do this to a
      * non-SELECT query, but we never have to; RETURNING lists can always be
      * modified in-place.)
      */
     if (upper_tlist_nontrivial)
     {
         Query      *newquery;
         List       *colnames;
         RangeTblEntry *rte;
         RangeTblRef *rtr;
 
         Assert(parse->commandType == CMD_SELECT);
 
         /* Most of the upper Query struct can be left as zeroes/nulls */
         newquery = makeNode(Query);
         newquery->commandType = CMD_SELECT;
         newquery->querySource = parse->querySource;
         newquery->canSetTag = true;
         newquery->targetList = upper_tlist;
 
         /* We need a moderately realistic colnames list for the subquery RTE */
         colnames = NIL;
         foreach(lc, parse->targetList)
         {
             TargetEntry *tle = (TargetEntry *) lfirst(lc);
 
             if (tle->resjunk)
                 continue;
             colnames = lappend(colnames,
                                makeString(tle->resname ? tle->resname : ""));
         }
 
         /* Build a suitable RTE for the subquery */
         rte = makeNode(RangeTblEntry);
         rte->rtekind = RTE_SUBQUERY;
         rte->subquery = parse;
         rte->eref = rte->alias = makeAlias("*SELECT*", colnames);
         rte->lateral = false;
         rte->inh = false;
         rte->inFromCl = true;
         newquery->rtable = list_make1(rte);
 
         rtr = makeNode(RangeTblRef);
         rtr->rtindex = 1;
         newquery->jointree = makeFromExpr(list_make1(rtr), NULL);
 
         /* Replace original query in the correct element of the query list */
         lfirst(parse_cell) = newquery;
     }
 
     /* Return tlist (possibly modified) if requested */
     if (resultTargetList)
         *resultTargetList = upper_tlist;
 
     return is_tuple_result;
 }

◆ check_sql_fn_statements()

void check_sql_fn_statements ( List * queryTreeList )

Definition at line 1510 of file functions.c.

References castNode, CMD_UTILITY, Query::commandType, elog, ereport, errcode(), errmsg(), ERROR, CallStmt::funcexpr, FuncExpr::funcid, get_func_arg_info(), HeapTupleIsValid, i, IsA, lfirst_node, ObjectIdGetDatum, PROCOID, ReleaseSysCache(), SearchSysCache1(), execution_state::stmt, and Query::utilityStmt.

Referenced by fmgr_sql_validator(), and init_sql_fcache().

 {
     ListCell   *lc;
 
     foreach(lc, queryTreeList)
     {
         Query      *query = lfirst_node(Query, lc);
 
         /*
          * Disallow procedures with output arguments.  The current
          * implementation would just throw the output values away, unless the
          * statement is the last one.  Per SQL standard, we should assign the
          * output values by name.  By disallowing this here, we preserve an
          * opportunity for future improvement.
          */
         if (query->commandType == CMD_UTILITY &&
             IsA(query->utilityStmt, CallStmt))
         {
             CallStmt   *stmt = castNode(CallStmt, query->utilityStmt);
             HeapTuple   tuple;
             int         numargs;
             Oid        *argtypes;
             char      **argnames;
             char       *argmodes;
             int         i;
 
             tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(stmt->funcexpr->funcid));
             if (!HeapTupleIsValid(tuple))
                 elog(ERROR, "cache lookup failed for function %u", stmt->funcexpr->funcid);
             numargs = get_func_arg_info(tuple, &argtypes, &argnames, &argmodes);
             ReleaseSysCache(tuple);
 
             for (i = 0; i < numargs; i++)
             {
                 if (argmodes && (argmodes[i] == PROARGMODE_INOUT || argmodes[i] == PROARGMODE_OUT))
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("calling procedures with output arguments is not supported in SQL functions")));
             }
         }
     }
 }

◆ coerce_fn_result_column()

static bool coerce_fn_result_column	(	TargetEntry *	src_tle,
		Oid	res_type,
		int32	res_typmod,
		bool	tlist_is_modifiable,
		List **	upper_tlist,
		bool *	upper_tlist_nontrivial
	)

static

Definition at line 1962 of file functions.c.

References COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, TargetEntry::expr, exprType(), lappend(), list_length(), makeTargetEntry(), makeVarFromTargetEntry(), TargetEntry::resname, and TargetEntry::ressortgroupref.

Referenced by check_sql_fn_retval().

 {
     TargetEntry *new_tle;
     Expr       *new_tle_expr;
     Node       *cast_result;
 
     /*
      * If the TLE has a sortgroupref marking, don't change it, as it probably
      * is referenced by ORDER BY, DISTINCT, etc, and changing its type would
      * break query semantics.  Otherwise, it's safe to modify in-place unless
      * the query as a whole has issues with that.
      */
     if (tlist_is_modifiable && src_tle->ressortgroupref == 0)
     {
         /* OK to modify src_tle in place, if necessary */
         cast_result = coerce_to_target_type(NULL,
                                             (Node *) src_tle->expr,
                                             exprType((Node *) src_tle->expr),
                                             res_type, res_typmod,
                                             COERCION_ASSIGNMENT,
                                             COERCE_IMPLICIT_CAST,
                                             -1);
         if (cast_result == NULL)
             return false;
         src_tle->expr = (Expr *) cast_result;
         /* Make a Var referencing the possibly-modified TLE */
         new_tle_expr = (Expr *) makeVarFromTargetEntry(1, src_tle);
     }
     else
     {
         /* Any casting must happen in the upper tlist */
         Var        *var = makeVarFromTargetEntry(1, src_tle);
 
         cast_result = coerce_to_target_type(NULL,
                                             (Node *) var,
                                             var->vartype,
                                             res_type, res_typmod,
                                             COERCION_ASSIGNMENT,
                                             COERCE_IMPLICIT_CAST,
                                             -1);
         if (cast_result == NULL)
             return false;
         /* Did the coercion actually do anything? */
         if (cast_result != (Node *) var)
             *upper_tlist_nontrivial = true;
         new_tle_expr = (Expr *) cast_result;
     }
     new_tle = makeTargetEntry(new_tle_expr,
                               list_length(*upper_tlist) + 1,
                               src_tle->resname, false);
     *upper_tlist = lappend(*upper_tlist, new_tle);
     return true;
 }

◆ CreateSQLFunctionDestReceiver()

DestReceiver* CreateSQLFunctionDestReceiver ( void )

Definition at line 2026 of file functions.c.

References DestSQLFunction, palloc0(), sqlfunction_destroy(), sqlfunction_receive(), sqlfunction_shutdown(), and sqlfunction_startup().

Referenced by CreateDestReceiver().

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

◆ fmgr_sql()

Datum fmgr_sql ( PG_FUNCTION_ARGS )

Definition at line 1005 of file functions.c.

Referenced by fmgr_info_cxt_security().

 {
     SQLFunctionCachePtr fcache;
     ErrorContextCallback sqlerrcontext;
     MemoryContext oldcontext;
     bool        randomAccess;
     bool        lazyEvalOK;
     bool        is_first;
     bool        pushed_snapshot;
     execution_state *es;
     TupleTableSlot *slot;
     Datum       result;
     List       *eslist;
     ListCell   *eslc;
 
     /*
      * Setup error traceback support for ereport()
      */
     sqlerrcontext.callback = sql_exec_error_callback;
     sqlerrcontext.arg = fcinfo->flinfo;
     sqlerrcontext.previous = error_context_stack;
     error_context_stack = &sqlerrcontext;
 
     /* 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);
     }
     else
     {
         randomAccess = false;
         lazyEvalOK = true;
     }
 
     /*
      * Initialize fcache (build plans) if first time through; or re-initialize
      * if the cache is stale.
      */
     fcache = (SQLFunctionCachePtr) fcinfo->flinfo->fn_extra;
 
     if (fcache != NULL)
     {
         if (fcache->lxid != MyProc->lxid ||
             !SubTransactionIsActive(fcache->subxid))
         {
             /* It's stale; unlink and delete */
             fcinfo->flinfo->fn_extra = NULL;
             MemoryContextDelete(fcache->fcontext);
             fcache = NULL;
         }
     }
 
     if (fcache == NULL)
     {
         init_sql_fcache(fcinfo, PG_GET_COLLATION(), lazyEvalOK);
         fcache = (SQLFunctionCachePtr) fcinfo->flinfo->fn_extra;
     }
 
     /*
      * Switch to context in which the fcache lives.  This ensures that our
      * tuplestore etc will have sufficient lifetime.  The sub-executor is
      * responsible for deleting per-tuple information.  (XXX in the case of a
      * long-lived FmgrInfo, this policy represents more memory leakage, but
      * it's not entirely clear where to keep stuff instead.)
      */
     oldcontext = MemoryContextSwitchTo(fcache->fcontext);
 
     /*
      * Find first unfinished query in function, and note whether it's the
      * first query.
      */
     eslist = fcache->func_state;
     es = NULL;
     is_first = true;
     foreach(eslc, eslist)
     {
         es = (execution_state *) lfirst(eslc);
 
         while (es && es->status == F_EXEC_DONE)
         {
             is_first = false;
             es = es->next;
         }
 
         if (es)
             break;
     }
 
     /*
      * Convert params to appropriate format if starting a fresh execution. (If
      * continuing execution, we can re-use prior params.)
      */
     if (is_first && es && es->status == F_EXEC_START)
         postquel_sub_params(fcache, fcinfo);
 
     /*
      * Build tuplestore to hold results, if we don't have one already. Note
      * it's in the query-lifespan context.
      */
     if (!fcache->tstore)
         fcache->tstore = tuplestore_begin_heap(randomAccess, false, work_mem);
 
     /*
      * 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->readonly_func)
             {
                 CommandCounterIncrement();
                 if (!pushed_snapshot)
                 {
                     PushActiveSnapshot(GetTransactionSnapshot());
                     pushed_snapshot = true;
                 }
                 else
                     UpdateActiveSnapshotCommandId();
             }
 
             postquel_start(es, fcache);
         }
         else if (!fcache->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 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->returnsSet)
             postquel_end(es);
 
         /*
          * 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, which might be in the next list.
          */
         es = es->next;
         while (!es)
         {
             eslc = lnext(eslist, eslc);
             if (!eslc)
                 break;          /* end of function */
 
             es = (execution_state *) lfirst(eslc);
 
             /*
              * 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;
             }
         }
     }
 
     /*
      * The tuplestore now contains whatever row(s) we are supposed to return.
      */
     if (fcache->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);
             /* Re-use the junkfilter's output slot to fetch back the tuple */
             Assert(fcache->junkFilter);
             slot = fcache->junkFilter->jf_resultSlot;
             if (!tuplestore_gettupleslot(fcache->tstore, true, false, slot))
                 elog(ERROR, "failed to fetch lazy-eval tuple");
             /* Extract the result as a datum, and copy out from the slot */
             result = postquel_get_single_result(slot, fcinfo,
                                                 fcache, oldcontext);
             /* Clear the tuplestore, but keep it for next time */
             /* NB: this might delete the slot's content, but we don't care */
             tuplestore_clear(fcache->tstore);
 
             /*
              * 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.  Clean up.
              */
             tuplestore_clear(fcache->tstore);
 
             /*
              * 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.)
              */
             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)
         {
             /* Re-use the junkfilter's output slot to fetch back the tuple */
             slot = fcache->junkFilter->jf_resultSlot;
             if (tuplestore_gettupleslot(fcache->tstore, true, false, slot))
                 result = postquel_get_single_result(slot, fcinfo,
                                                     fcache, oldcontext);
             else
             {
                 fcinfo->isnull = true;
                 result = (Datum) 0;
             }
         }
         else
         {
             /* Should only get here for VOID functions and procedures */
             Assert(fcache->rettype == VOIDOID);
             fcinfo->isnull = true;
             result = (Datum) 0;
         }
 
         /* Clear the tuplestore, but keep it for next time */
         tuplestore_clear(fcache->tstore);
     }
 
     /* 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
      * the execution states to start over again on next call.
      */
     if (es == NULL)
     {
         foreach(eslc, fcache->func_state)
         {
             es = (execution_state *) lfirst(eslc);
             while (es)
             {
                 es->status = F_EXEC_START;
                 es = es->next;
             }
         }
     }
 
     error_context_stack = sqlerrcontext.previous;
 
     MemoryContextSwitchTo(oldcontext);
 
     return result;
 }

◆ init_execution_state()

static List * init_execution_state	(	List *	queryTree_list,
		SQLFunctionCachePtr	fcache,
		bool	lazyEvalOK
	)

static

Definition at line 479 of file functions.c.

References PlannedStmt::canSetTag, Query::canSetTag, CMD_SELECT, CMD_UTILITY, CommandIsReadOnly(), PlannedStmt::commandType, Query::commandType, CreateCommandTag(), CURSOR_OPT_PARALLEL_OK, ereport, errcode(), errmsg(), ERROR, F_EXEC_START, PlannedStmt::hasModifyingCTE, IsA, SQLFunctionCache::junkFilter, lappend(), execution_state::lazyEval, SQLFunctionCache::lazyEval, lfirst_node, makeNode, execution_state::next, NIL, palloc(), pg_plan_query(), execution_state::qd, SQLFunctionCache::readonly_func, execution_state::setsResult, execution_state::status, execution_state::stmt, PlannedStmt::stmt_len, Query::stmt_len, PlannedStmt::stmt_location, Query::stmt_location, PlannedStmt::utilityStmt, and Query::utilityStmt.

Referenced by init_sql_fcache().

 {
     List       *eslist = NIL;
     execution_state *lasttages = NULL;
     ListCell   *lc1;
 
     foreach(lc1, queryTree_list)
     {
         List       *qtlist = lfirst_node(List, lc1);
         execution_state *firstes = NULL;
         execution_state *preves = NULL;
         ListCell   *lc2;
 
         foreach(lc2, qtlist)
         {
             Query      *queryTree = lfirst_node(Query, lc2);
             PlannedStmt *stmt;
             execution_state *newes;
 
             /* Plan the query if needed */
             if (queryTree->commandType == CMD_UTILITY)
             {
                 /* Utility commands require no planning. */
                 stmt = makeNode(PlannedStmt);
                 stmt->commandType = CMD_UTILITY;
                 stmt->canSetTag = queryTree->canSetTag;
                 stmt->utilityStmt = queryTree->utilityStmt;
                 stmt->stmt_location = queryTree->stmt_location;
                 stmt->stmt_len = queryTree->stmt_len;
             }
             else
                 stmt = pg_plan_query(queryTree,
                                      CURSOR_OPT_PARALLEL_OK,
                                      NULL);
 
             /*
              * Precheck all commands for validity in a function.  This should
              * generally match the restrictions spi.c applies.
              */
             if (stmt->commandType == CMD_UTILITY)
             {
                 if (IsA(stmt->utilityStmt, CopyStmt) &&
                     ((CopyStmt *) stmt->utilityStmt)->filename == NULL)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("cannot COPY to/from client in a SQL function")));
 
                 if (IsA(stmt->utilityStmt, TransactionStmt))
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     /* translator: %s is a SQL statement name */
                              errmsg("%s is not allowed in a SQL function",
                                     CreateCommandTag(stmt->utilityStmt))));
             }
 
             if (fcache->readonly_func && !CommandIsReadOnly(stmt))
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 /* translator: %s is a SQL statement name */
                          errmsg("%s is not allowed in a non-volatile function",
                                 CreateCommandTag((Node *) stmt))));
 
             /* OK, build the execution_state for this query */
             newes = (execution_state *) palloc(sizeof(execution_state));
             if (preves)
                 preves->next = newes;
             else
                 firstes = newes;
 
             newes->next = NULL;
             newes->status = F_EXEC_START;
             newes->setsResult = false;  /* might change below */
             newes->lazyEval = false;    /* might change below */
             newes->stmt = stmt;
             newes->qd = NULL;
 
             if (queryTree->canSetTag)
                 lasttages = newes;
 
             preves = newes;
         }
 
         eslist = lappend(eslist, firstes);
     }
 
     /*
      * Mark the last canSetTag query as delivering the function result; then,
      * if it is a plain SELECT, mark it for lazy evaluation. If it's not a
      * SELECT we must always run it to completion.
      *
      * Note: at some point we might add additional criteria for whether to use
      * lazy eval.  However, we should prefer to use it whenever the function
      * doesn't return set, since fetching more than one row is useless in that
      * case.
      *
      * Note: don't set setsResult if the function returns VOID, as evidenced
      * by not having made a junkfilter.  This ensures we'll throw away any
      * output from the last statement in such a function.
      */
     if (lasttages && fcache->junkFilter)
     {
         lasttages->setsResult = true;
         if (lazyEvalOK &&
             lasttages->stmt->commandType == CMD_SELECT &&
             !lasttages->stmt->hasModifyingCTE)
             fcache->lazyEval = lasttages->lazyEval = true;
     }
 
     return eslist;
 }

◆ init_sql_fcache()

static void init_sql_fcache	(	FunctionCallInfo	fcinfo,
		Oid	collation,
		bool	lazyEvalOK
	)

static

Definition at line 596 of file functions.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, BlessTupleDesc(), check_sql_fn_retval(), check_sql_fn_statements(), elog, ERROR, ExecInitJunkFilter(), ExecInitJunkFilterConversion(), SQLFunctionCache::fcontext, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, FmgrInfo::fn_oid, SQLFunctionCache::fname, SQLFunctionCache::func_state, get_call_result_type(), get_typlenbyval(), GetCurrentSubTransactionId(), GETSTRUCT, HeapTupleIsValid, init_execution_state(), JunkFilter::jf_resultSlot, SQLFunctionCache::junkFilter, lappend(), lfirst_node, list_concat(), PGPROC::lxid, SQLFunctionCache::lxid, MakeSingleTupleTableSlot(), MemoryContextSetIdentifier(), MemoryContextSwitchTo(), MyProc, NameStr, NIL, ObjectIdGetDatum, palloc0(), pg_analyze_and_rewrite_params(), pg_parse_query(), SQLFunctionCache::pinfo, prepare_sql_fn_parse_info(), PROCOID, pstrdup(), SQLFunctionCache::readonly_func, ReleaseSysCache(), SQLFunctionCache::rettype, SQLFunctionCache::returnsSet, SQLFunctionCache::returnsTuple, SearchSysCache1(), sql_fn_parser_setup(), SQLFunctionCache::src, SQLFunctionCache::subxid, SysCacheGetAttr(), TextDatumGetCString, TupleTableSlot::tts_tupleDescriptor, TTSOpsMinimalTuple, SQLFunctionCache::typbyval, type_is_rowtype(), and SQLFunctionCache::typlen.

Referenced by fmgr_sql().

 {
     FmgrInfo   *finfo = fcinfo->flinfo;
     Oid         foid = finfo->fn_oid;
     MemoryContext fcontext;
     MemoryContext oldcontext;
     Oid         rettype;
     TupleDesc   rettupdesc;
     HeapTuple   procedureTuple;
     Form_pg_proc procedureStruct;
     SQLFunctionCachePtr fcache;
     List       *raw_parsetree_list;
     List       *queryTree_list;
     List       *flat_query_list;
     List       *resulttlist;
     ListCell   *lc;
     Datum       tmp;
     bool        isNull;
 
     /*
      * Create memory context that holds all the SQLFunctionCache data.  It
      * must be a child of whatever context holds the FmgrInfo.
      */
     fcontext = AllocSetContextCreate(finfo->fn_mcxt,
                                      "SQL function",
                                      ALLOCSET_DEFAULT_SIZES);
 
     oldcontext = MemoryContextSwitchTo(fcontext);
 
     /*
      * Create the struct proper, link it to fcontext and fn_extra.  Once this
      * is done, we'll be able to recover the memory after failure, even if the
      * FmgrInfo is long-lived.
      */
     fcache = (SQLFunctionCachePtr) palloc0(sizeof(SQLFunctionCache));
     fcache->fcontext = fcontext;
     finfo->fn_extra = (void *) fcache;
 
     /*
      * get the procedure tuple corresponding to the given function Oid
      */
     procedureTuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(foid));
     if (!HeapTupleIsValid(procedureTuple))
         elog(ERROR, "cache lookup failed for function %u", foid);
     procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
 
     /*
      * copy function name immediately for use by error reporting callback, and
      * for use as memory context identifier
      */
     fcache->fname = pstrdup(NameStr(procedureStruct->proname));
     MemoryContextSetIdentifier(fcontext, fcache->fname);
 
     /*
      * Resolve any polymorphism, obtaining the actual result type, and the
      * corresponding tupdesc if it's a rowtype.
      */
     (void) get_call_result_type(fcinfo, &rettype, &rettupdesc);
 
     fcache->rettype = rettype;
 
     /* Fetch the typlen and byval info for the result type */
     get_typlenbyval(rettype, &fcache->typlen, &fcache->typbyval);
 
     /* Remember whether we're returning setof something */
     fcache->returnsSet = procedureStruct->proretset;
 
     /* Remember if function is STABLE/IMMUTABLE */
     fcache->readonly_func =
         (procedureStruct->provolatile != PROVOLATILE_VOLATILE);
 
     /*
      * We need the actual argument types to pass to the parser.  Also make
      * sure that parameter symbols are considered to have the function's
      * resolved input collation.
      */
     fcache->pinfo = prepare_sql_fn_parse_info(procedureTuple,
                                               finfo->fn_expr,
                                               collation);
 
     /*
      * And of course we need the function body text.
      */
     tmp = SysCacheGetAttr(PROCOID,
                           procedureTuple,
                           Anum_pg_proc_prosrc,
                           &isNull);
     if (isNull)
         elog(ERROR, "null prosrc for function %u", foid);
     fcache->src = TextDatumGetCString(tmp);
 
     /*
      * Parse and rewrite the queries in the function text.  Use sublists to
      * keep track of the original query boundaries.  But we also build a
      * "flat" list of the rewritten queries to pass to check_sql_fn_retval.
      * This is because the last canSetTag query determines the result type
      * independently of query boundaries --- and it might not be in the last
      * sublist, for example if the last query rewrites to DO INSTEAD NOTHING.
      * (It might not be unreasonable to throw an error in such a case, but
      * this is the historical behavior and it doesn't seem worth changing.)
      *
      * Note: since parsing and planning is done in fcontext, we will generate
      * a lot of cruft that lives as long as the fcache does.  This is annoying
      * but we'll not worry about it until the module is rewritten to use
      * plancache.c.
      */
     raw_parsetree_list = pg_parse_query(fcache->src);
 
     queryTree_list = NIL;
     flat_query_list = NIL;
     foreach(lc, raw_parsetree_list)
     {
         RawStmt    *parsetree = lfirst_node(RawStmt, lc);
         List       *queryTree_sublist;
 
         queryTree_sublist = pg_analyze_and_rewrite_params(parsetree,
                                                           fcache->src,
                                                           (ParserSetupHook) sql_fn_parser_setup,
                                                           fcache->pinfo,
                                                           NULL);
         queryTree_list = lappend(queryTree_list, queryTree_sublist);
         flat_query_list = list_concat(flat_query_list, queryTree_sublist);
     }
 
     check_sql_fn_statements(flat_query_list);
 
     /*
      * Check that the function returns the type it claims to.  Although in
      * simple cases this was already done when the function was defined, we
      * have to recheck because database objects used in the function's queries
      * might have changed type.  We'd have to recheck anyway if the function
      * had any polymorphic arguments.  Moreover, check_sql_fn_retval takes
      * care of injecting any required column type coercions.  (But we don't
      * ask it to insert nulls for dropped columns; the junkfilter handles
      * that.)
      *
      * Note: we set fcache->returnsTuple according to whether we are returning
      * the whole tuple result or just a single column.  In the latter case we
      * clear returnsTuple because we need not act different from the scalar
      * result case, even if it's a rowtype column.  (However, we have to force
      * lazy eval mode in that case; otherwise we'd need extra code to expand
      * the rowtype column into multiple columns, since we have no way to
      * notify the caller that it should do that.)
      */
     fcache->returnsTuple = check_sql_fn_retval(flat_query_list,
                                                rettype,
                                                rettupdesc,
                                                false,
                                                &resulttlist);
 
     /*
      * Construct a JunkFilter we can use to coerce the returned rowtype to the
      * desired form, unless the result type is VOID, in which case there's
      * nothing to coerce to.  (XXX Frequently, the JunkFilter isn't doing
      * anything very interesting, but much of this module expects it to be
      * there anyway.)
      */
     if (rettype != VOIDOID)
     {
         TupleTableSlot *slot = MakeSingleTupleTableSlot(NULL,
                                                         &TTSOpsMinimalTuple);
 
         /*
          * If the result is composite, *and* we are returning the whole tuple
          * result, we need to insert nulls for any dropped columns.  In the
          * single-column-result case, there might be dropped columns within
          * the composite column value, but it's not our problem here.  There
          * should be no resjunk entries in resulttlist, so in the second case
          * the JunkFilter is certainly a no-op.
          */
         if (rettupdesc && fcache->returnsTuple)
             fcache->junkFilter = ExecInitJunkFilterConversion(resulttlist,
                                                               rettupdesc,
                                                               slot);
         else
             fcache->junkFilter = ExecInitJunkFilter(resulttlist, slot);
     }
 
     if (fcache->returnsTuple)
     {
         /* Make sure output rowtype is properly blessed */
         BlessTupleDesc(fcache->junkFilter->jf_resultSlot->tts_tupleDescriptor);
     }
     else if (fcache->returnsSet && type_is_rowtype(fcache->rettype))
     {
         /*
          * Returning rowtype as if it were scalar --- materialize won't work.
          * Right now it's sufficient to override any caller preference for
          * materialize mode, but to add more smarts in init_execution_state
          * about this, we'd probably need a three-way flag instead of bool.
          */
         lazyEvalOK = true;
     }
 
     /* Finally, plan the queries */
     fcache->func_state = init_execution_state(queryTree_list,
                                               fcache,
                                               lazyEvalOK);
 
     /* Mark fcache with time of creation to show it's valid */
     fcache->lxid = MyProc->lxid;
     fcache->subxid = GetCurrentSubTransactionId();
 
     ReleaseSysCache(procedureTuple);
 
     MemoryContextSwitchTo(oldcontext);
 }

◆ postquel_end()

static void postquel_end ( execution_state * es )

static

Definition at line 902 of file functions.c.

References CMD_UTILITY, QueryDesc::dest, ExecutorEnd(), ExecutorFinish(), F_EXEC_DONE, FreeQueryDesc(), QueryDesc::operation, execution_state::qd, _DestReceiver::rDestroy, and execution_state::status.

Referenced by fmgr_sql(), and ShutdownSQLFunction().

 {
     /* mark status done to ensure we don't do ExecutorEnd twice */
     es->status = F_EXEC_DONE;
 
     /* Utility commands don't need Executor. */
     if (es->qd->operation != CMD_UTILITY)
     {
         ExecutorFinish(es->qd);
         ExecutorEnd(es->qd);
     }
 
     es->qd->dest->rDestroy(es->qd->dest);
 
     FreeQueryDesc(es->qd);
     es->qd = NULL;
 }

◆ postquel_get_single_result()

static Datum postquel_get_single_result	(	TupleTableSlot *	slot,
		FunctionCallInfo	fcinfo,
		SQLFunctionCachePtr	fcache,
		MemoryContext	resultcontext
	)

static

Definition at line 962 of file functions.c.

References datumCopy(), ExecFetchSlotHeapTupleDatum(), FunctionCallInfoBaseData::isnull, MemoryContextSwitchTo(), SQLFunctionCache::returnsTuple, slot_getattr(), SQLFunctionCache::typbyval, SQLFunctionCache::typlen, and value.

Referenced by fmgr_sql().

 {
     Datum       value;
     MemoryContext oldcontext;
 
     /*
      * Set up to return the function value.  For pass-by-reference datatypes,
      * be sure to allocate the result in resultcontext, not the current memory
      * context (which has query lifespan).  We can't leave the data in the
      * TupleTableSlot because we intend to clear the slot before returning.
      */
     oldcontext = MemoryContextSwitchTo(resultcontext);
 
     if (fcache->returnsTuple)
     {
         /* We must return the whole tuple as a Datum. */
         fcinfo->isnull = false;
         value = ExecFetchSlotHeapTupleDatum(slot);
     }
     else
     {
         /*
          * Returning a scalar, which we have to extract from the first column
          * of the SELECT result, and then copy into result context if needed.
          */
         value = slot_getattr(slot, 1, &(fcinfo->isnull));
 
         if (!fcinfo->isnull)
             value = datumCopy(value, fcache->typbyval, fcache->typlen);
     }
 
     MemoryContextSwitchTo(oldcontext);
 
     return value;
 }

◆ postquel_getnext()

static bool postquel_getnext	(	execution_state *	es,
		SQLFunctionCachePtr	fcache
	)

static

Definition at line 868 of file functions.c.

References CMD_UTILITY, QueryDesc::dest, EState::es_processed, QueryDesc::estate, ExecutorRun(), ForwardScanDirection, execution_state::lazyEval, QueryDesc::operation, QueryDesc::params, QueryDesc::plannedstmt, PROCESS_UTILITY_QUERY, ProcessUtility(), execution_state::qd, QueryDesc::queryEnv, SQLFunctionCache::returnsSet, and SQLFunctionCache::src.

Referenced by fmgr_sql().

 {
     bool        result;
 
     if (es->qd->operation == CMD_UTILITY)
     {
         ProcessUtility(es->qd->plannedstmt,
                        fcache->src,
                        PROCESS_UTILITY_QUERY,
                        es->qd->params,
                        es->qd->queryEnv,
                        es->qd->dest,
                        NULL);
         result = true;          /* never stops early */
     }
     else
     {
         /* Run regular commands to completion unless lazyEval */
         uint64      count = (es->lazyEval) ? 1 : 0;
 
         ExecutorRun(es->qd, ForwardScanDirection, count, !fcache->returnsSet || !es->lazyEval);
 
         /*
          * If we requested run to completion OR there was no tuple returned,
          * command must be complete.
          */
         result = (count == 0 || es->qd->estate->es_processed == 0);
     }
 
     return result;
 }

◆ postquel_start()

static void postquel_start	(	execution_state *	es,
		SQLFunctionCachePtr	fcache
	)

static

Definition at line 806 of file functions.c.

References ActiveSnapshotSet(), Assert, CMD_UTILITY, CreateDestReceiver(), CreateQueryDesc(), CurrentMemoryContext, DR_sqlfunction::cxt, generate_unaccent_rules::dest, DestSQLFunction, EXEC_FLAG_SKIP_TRIGGERS, ExecutorStart(), F_EXEC_RUN, DR_sqlfunction::filter, GetActiveSnapshot(), InvalidSnapshot, SQLFunctionCache::junkFilter, execution_state::lazyEval, _DestReceiver::mydest, None_Receiver, QueryDesc::operation, SQLFunctionCache::paramLI, DR_sqlfunction::pub, execution_state::qd, QueryDesc::queryEnv, execution_state::setsResult, SQLFunctionCache::src, execution_state::status, execution_state::stmt, DR_sqlfunction::tstore, and SQLFunctionCache::tstore.

Referenced by fmgr_sql().

 {
     DestReceiver *dest;
 
     Assert(es->qd == NULL);
 
     /* Caller should have ensured a suitable snapshot is active */
     Assert(ActiveSnapshotSet());
 
     /*
      * If this query produces the function result, send its output to the
      * tuplestore; else discard any output.
      */
     if (es->setsResult)
     {
         DR_sqlfunction *myState;
 
         dest = CreateDestReceiver(DestSQLFunction);
         /* pass down the needed info to the dest receiver routines */
         myState = (DR_sqlfunction *) dest;
         Assert(myState->pub.mydest == DestSQLFunction);
         myState->tstore = fcache->tstore;
         myState->cxt = CurrentMemoryContext;
         myState->filter = fcache->junkFilter;
     }
     else
         dest = None_Receiver;
 
     es->qd = CreateQueryDesc(es->stmt,
                              fcache->src,
                              GetActiveSnapshot(),
                              InvalidSnapshot,
                              dest,
                              fcache->paramLI,
                              es->qd ? es->qd->queryEnv : NULL,
                              0);
 
     /* Utility commands don't need Executor. */
     if (es->qd->operation != CMD_UTILITY)
     {
         /*
          * In lazyEval mode, do not let the executor set up an AfterTrigger
          * context.  This is necessary not just an optimization, because we
          * mustn't exit from the function execution with a stacked
          * AfterTrigger level still active.  We are careful not to select
          * lazyEval mode for any statement that could possibly queue triggers.
          */
         int         eflags;
 
         if (es->lazyEval)
             eflags = EXEC_FLAG_SKIP_TRIGGERS;
         else
             eflags = 0;         /* default run-to-completion flags */
         ExecutorStart(es->qd, eflags);
     }
 
     es->status = F_EXEC_RUN;
 }

◆ postquel_sub_params()

static void postquel_sub_params	(	SQLFunctionCachePtr	fcache,
		FunctionCallInfo	fcinfo
	)

static

Definition at line 922 of file functions.c.

References FunctionCallInfoBaseData::args, SQLFunctionParseInfo::argtypes, Assert, i, ParamExternData::isnull, NullableDatum::isnull, makeParamList(), FunctionCallInfoBaseData::nargs, ParamListInfoData::numParams, SQLFunctionCache::paramLI, ParamListInfoData::params, ParamExternData::pflags, SQLFunctionCache::pinfo, ParamExternData::ptype, ParamExternData::value, and NullableDatum::value.

Referenced by fmgr_sql().

 {
     int         nargs = fcinfo->nargs;
 
     if (nargs > 0)
     {
         ParamListInfo paramLI;
 
         if (fcache->paramLI == NULL)
         {
             paramLI = makeParamList(nargs);
             fcache->paramLI = paramLI;
         }
         else
         {
             paramLI = fcache->paramLI;
             Assert(paramLI->numParams == nargs);
         }
 
         for (int i = 0; i < nargs; i++)
         {
             ParamExternData *prm = &paramLI->params[i];
 
             prm->value = fcinfo->args[i].value;
             prm->isnull = fcinfo->args[i].isnull;
             prm->pflags = 0;
             prm->ptype = fcache->pinfo->argtypes[i];
         }
     }
     else
         fcache->paramLI = NULL;
 }

◆ prepare_sql_fn_parse_info()

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

Definition at line 189 of file functions.c.

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, PROCNAMEARGSNSP, pstrdup(), and SysCacheGetAttr().

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

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

◆ ShutdownSQLFunction()

static void ShutdownSQLFunction ( Datum arg )

static

Definition at line 1464 of file functions.c.

References DatumGetPointer, F_EXEC_RUN, F_EXEC_START, SQLFunctionCache::func_state, lfirst, execution_state::next, PopActiveSnapshot(), postquel_end(), PushActiveSnapshot(), execution_state::qd, SQLFunctionCache::readonly_func, SQLFunctionCache::shutdown_reg, QueryDesc::snapshot, execution_state::status, SQLFunctionCache::tstore, and tuplestore_end().

Referenced by fmgr_sql().

 {
     SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) DatumGetPointer(arg);
     execution_state *es;
     ListCell   *lc;
 
     foreach(lc, fcache->func_state)
     {
         es = (execution_state *) lfirst(lc);
         while (es)
         {
             /* Shut down anything still running */
             if (es->status == F_EXEC_RUN)
             {
                 /* Re-establish active snapshot for any called functions */
                 if (!fcache->readonly_func)
                     PushActiveSnapshot(es->qd->snapshot);
 
                 postquel_end(es);
 
                 if (!fcache->readonly_func)
                     PopActiveSnapshot();
             }
 
             /* Reset states to START in case we're called again */
             es->status = F_EXEC_START;
             es = es->next;
         }
     }
 
     /* Release tuplestore if we have one */
     if (fcache->tstore)
         tuplestore_end(fcache->tstore);
     fcache->tstore = NULL;
 
     /* execUtils will deregister the callback... */
     fcache->shutdown_reg = false;
 }

◆ sql_exec_error_callback()

static void sql_exec_error_callback ( void * arg )

static

Definition at line 1382 of file functions.c.

References errcontext, errposition(), FmgrInfo::fn_extra, SQLFunctionCache::fname, SQLFunctionCache::func_state, geterrposition(), internalerrposition(), internalerrquery(), lfirst, execution_state::next, execution_state::qd, and SQLFunctionCache::src.

Referenced by fmgr_sql().

 {
     FmgrInfo   *flinfo = (FmgrInfo *) arg;
     SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) flinfo->fn_extra;
     int         syntaxerrposition;
 
     /*
      * We can do nothing useful if init_sql_fcache() didn't get as far as
      * saving the function name
      */
     if (fcache == NULL || fcache->fname == NULL)
         return;
 
     /*
      * If there is a syntax error position, convert to internal syntax error
      */
     syntaxerrposition = geterrposition();
     if (syntaxerrposition > 0 && fcache->src != NULL)
     {
         errposition(0);
         internalerrposition(syntaxerrposition);
         internalerrquery(fcache->src);
     }
 
     /*
      * Try to determine where in the function we failed.  If there is a query
      * with non-null QueryDesc, finger it.  (We check this rather than looking
      * for F_EXEC_RUN state, so that errors during ExecutorStart or
      * ExecutorEnd are blamed on the appropriate query; see postquel_start and
      * postquel_end.)
      */
     if (fcache->func_state)
     {
         execution_state *es;
         int         query_num;
         ListCell   *lc;
 
         es = NULL;
         query_num = 1;
         foreach(lc, fcache->func_state)
         {
             es = (execution_state *) lfirst(lc);
             while (es)
             {
                 if (es->qd)
                 {
                     errcontext("SQL function \"%s\" statement %d",
                                fcache->fname, query_num);
                     break;
                 }
                 es = es->next;
             }
             if (es)
                 break;
             query_num++;
         }
         if (es == NULL)
         {
             /*
              * couldn't identify a running query; might be function entry,
              * function exit, or between queries.
              */
             errcontext("SQL function \"%s\"", fcache->fname);
         }
     }
     else
     {
         /*
          * Assume we failed during init_sql_fcache().  (It's possible that the
          * function actually has an empty body, but in that case we may as
          * well report all errors as being "during startup".)
          */
         errcontext("SQL function \"%s\" during startup", fcache->fname);
     }
 }

◆ sql_fn_make_param()

static Node * sql_fn_make_param	(	SQLFunctionParseInfoPtr	pinfo,
		int	paramno,
		int	location
	)

static

Definition at line 425 of file functions.c.

References SQLFunctionParseInfo::argtypes, SQLFunctionParseInfo::collation, get_typcollation(), Param::location, makeNode, OidIsValid, PARAM_EXTERN, Param::paramcollid, Param::paramid, Param::paramkind, Param::paramtype, and Param::paramtypmod.

Referenced by sql_fn_param_ref(), and sql_fn_resolve_param_name().

 {
     Param      *param;
 
     param = makeNode(Param);
     param->paramkind = PARAM_EXTERN;
     param->paramid = paramno;
     param->paramtype = pinfo->argtypes[paramno - 1];
     param->paramtypmod = -1;
     param->paramcollid = get_typcollation(param->paramtype);
     param->location = location;
 
     /*
      * If we have a function input collation, allow it to override the
      * type-derived collation for parameter symbols.  (XXX perhaps this should
      * not happen if the type collation is not default?)
      */
     if (OidIsValid(pinfo->collation) && OidIsValid(param->paramcollid))
         param->paramcollid = pinfo->collation;
 
     return (Node *) param;
 }

◆ sql_fn_param_ref()

static Node * sql_fn_param_ref	(	ParseState *	pstate,
		ParamRef *	pref
	)

static

Definition at line 409 of file functions.c.

References ParamRef::location, SQLFunctionParseInfo::nargs, ParamRef::number, ParseState::p_ref_hook_state, and sql_fn_make_param().

Referenced by sql_fn_parser_setup().

 {
     SQLFunctionParseInfoPtr pinfo = (SQLFunctionParseInfoPtr) pstate->p_ref_hook_state;
     int         paramno = pref->number;
 
     /* Check parameter number is valid */
     if (paramno <= 0 || paramno > pinfo->nargs)
         return NULL;            /* unknown parameter number */
 
     return sql_fn_make_param(pinfo, paramno, pref->location);
 }

◆ sql_fn_parser_setup()

void sql_fn_parser_setup	(	struct ParseState *	pstate,
		SQLFunctionParseInfoPtr	pinfo
	)

Definition at line 278 of file functions.c.

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(), init_sql_fcache(), inline_function(), and inline_set_returning_function().

 {
     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 = (void *) pinfo;
 }

◆ sql_fn_post_column_ref()

static Node * sql_fn_post_column_ref	(	ParseState *	pstate,
		ColumnRef *	cref,
		Node *	var
	)

static

Definition at line 291 of file functions.c.

References Assert, ColumnRef::fields, SQLFunctionParseInfo::fname, IsA, linitial, list_length(), list_make1, llast, ColumnRef::location, lsecond, lthird, ParseState::p_last_srf, ParseState::p_ref_hook_state, ParseFuncOrColumn(), sql_fn_resolve_param_name(), and strVal.

Referenced by sql_fn_parser_setup().

 {
     SQLFunctionParseInfoPtr pinfo = (SQLFunctionParseInfoPtr) pstate->p_ref_hook_state;
     int         nnames;
     Node       *field1;
     Node       *subfield = NULL;
     const char *name1;
     const char *name2 = NULL;
     Node       *param;
 
     /*
      * Never override a table-column reference.  This corresponds to
      * considering the parameter names to appear in a scope outside the
      * individual SQL commands, which is what we want.
      */
     if (var != NULL)
         return NULL;
 
     /*----------
      * The allowed syntaxes are:
      *
      * A        A = parameter name
      * A.B      A = function name, B = parameter name
      *          OR: A = record-typed parameter name, B = field name
      *          (the first possibility takes precedence)
      * A.B.C    A = function name, B = record-typed parameter name,
      *          C = field name
      * A.*      Whole-row reference to composite parameter A.
      * A.B.*    Same, with A = function name, B = parameter name
      *
      * Here, it's sufficient to ignore the "*" in the last two cases --- the
      * main parser will take care of expanding the whole-row reference.
      *----------
      */
     nnames = list_length(cref->fields);
 
     if (nnames > 3)
         return NULL;
 
     if (IsA(llast(cref->fields), A_Star))
         nnames--;
 
     field1 = (Node *) linitial(cref->fields);
     Assert(IsA(field1, String));
     name1 = strVal(field1);
     if (nnames > 1)
     {
         subfield = (Node *) lsecond(cref->fields);
         Assert(IsA(subfield, String));
         name2 = strVal(subfield);
     }
 
     if (nnames == 3)
     {
         /*
          * Three-part name: if the first part doesn't match the function name,
          * we can fail immediately. Otherwise, look up the second part, and
          * take the third part to be a field reference.
          */
         if (strcmp(name1, pinfo->fname) != 0)
             return NULL;
 
         param = sql_fn_resolve_param_name(pinfo, name2, cref->location);
 
         subfield = (Node *) lthird(cref->fields);
         Assert(IsA(subfield, String));
     }
     else if (nnames == 2 && strcmp(name1, pinfo->fname) == 0)
     {
         /*
          * Two-part name with first part matching function name: first see if
          * second part matches any parameter name.
          */
         param = sql_fn_resolve_param_name(pinfo, name2, cref->location);
 
         if (param)
         {
             /* Yes, so this is a parameter reference, no subfield */
             subfield = NULL;
         }
         else
         {
             /* No, so try to match as parameter name and subfield */
             param = sql_fn_resolve_param_name(pinfo, name1, cref->location);
         }
     }
     else
     {
         /* Single name, or parameter name followed by subfield */
         param = sql_fn_resolve_param_name(pinfo, name1, cref->location);
     }
 
     if (!param)
         return NULL;            /* No match */
 
     if (subfield)
     {
         /*
          * Must be a reference to a field of a composite parameter; otherwise
          * ParseFuncOrColumn will return NULL, and we'll fail back at the
          * caller.
          */
         param = ParseFuncOrColumn(pstate,
                                   list_make1(subfield),
                                   list_make1(param),
                                   pstate->p_last_srf,
                                   NULL,
                                   false,
                                   cref->location);
     }
 
     return param;
 }

◆ sql_fn_resolve_param_name()

static Node * sql_fn_resolve_param_name	(	SQLFunctionParseInfoPtr	pinfo,
		const char *	paramname,
		int	location
	)

static

Definition at line 455 of file functions.c.

References SQLFunctionParseInfo::argnames, i, SQLFunctionParseInfo::nargs, and sql_fn_make_param().

Referenced by sql_fn_post_column_ref().

 {
     int         i;
 
     if (pinfo->argnames == NULL)
         return NULL;
 
     for (i = 0; i < pinfo->nargs; i++)
     {
         if (pinfo->argnames[i] && strcmp(pinfo->argnames[i], paramname) == 0)
             return sql_fn_make_param(pinfo, i + 1, location);
     }
 
     return NULL;
 }

◆ sqlfunction_destroy()

static void sqlfunction_destroy ( DestReceiver * self )

static

Definition at line 2080 of file functions.c.

References pfree().

Referenced by CreateSQLFunctionDestReceiver().

 {
     pfree(self);
 }

◆ sqlfunction_receive()

static bool sqlfunction_receive	(	TupleTableSlot *	slot,
		DestReceiver *	self
	)

static

Definition at line 2054 of file functions.c.

References ExecFilterJunk(), DR_sqlfunction::filter, DR_sqlfunction::tstore, and tuplestore_puttupleslot().

Referenced by CreateSQLFunctionDestReceiver().

 {
     DR_sqlfunction *myState = (DR_sqlfunction *) self;
 
     /* Filter tuple as needed */
     slot = ExecFilterJunk(myState->filter, slot);
 
     /* Store the filtered tuple into the tuplestore */
     tuplestore_puttupleslot(myState->tstore, slot);
 
     return true;
 }

◆ sqlfunction_shutdown()

static void sqlfunction_shutdown ( DestReceiver * self )

static

Definition at line 2071 of file functions.c.

Referenced by CreateSQLFunctionDestReceiver().

 {
     /* no-op */
 }

◆ sqlfunction_startup()

static void sqlfunction_startup	(	DestReceiver *	self,
		int	operation,
		TupleDesc	typeinfo
	)

static

Definition at line 2045 of file functions.c.

Referenced by CreateSQLFunctionDestReceiver().

 {
     /* no-op */
 }

Data Structures

Typedefs

Enumerations

Functions

Typedef Documentation

◆ execution_state

◆ SQLFunctionCachePtr

◆ SQLFunctionParseInfo

Enumeration Type Documentation

◆ ExecStatus

Function Documentation

◆ check_sql_fn_retval()

◆ check_sql_fn_statements()

◆ coerce_fn_result_column()

◆ CreateSQLFunctionDestReceiver()

◆ fmgr_sql()

◆ init_execution_state()

◆ init_sql_fcache()

◆ postquel_end()

◆ postquel_get_single_result()

◆ postquel_getnext()

◆ postquel_start()

◆ postquel_sub_params()

◆ prepare_sql_fn_parse_info()

◆ ShutdownSQLFunction()

◆ sql_exec_error_callback()

◆ sql_fn_make_param()

◆ sql_fn_param_ref()

◆ sql_fn_parser_setup()

◆ sql_fn_post_column_ref()

◆ sql_fn_resolve_param_name()

◆ sqlfunction_destroy()

◆ sqlfunction_receive()

◆ sqlfunction_shutdown()

◆ sqlfunction_startup()