functions.c File Reference

#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_collate.h"
#include "parser/parse_func.h"
#include "rewrite/rewriteHandler.h"
#include "storage/proc.h"
#include "tcop/utility.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/funccache.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for functions.c:

Go to the source code of this file.

Data Structures
struct	DR_sqlfunction
struct	execution_state
struct	SQLFunctionHashEntry
struct	SQLFunctionCache

Typedefs
typedef struct execution_state	execution_state
typedef struct SQLFunctionHashEntry	SQLFunctionHashEntry
typedef struct SQLFunctionCache	SQLFunctionCache
typedef SQLFunctionCache *	SQLFunctionCachePtr

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 SQLFunctionCache *	init_sql_fcache (FunctionCallInfo fcinfo, bool lazyEvalOK)
static bool	init_execution_state (SQLFunctionCachePtr fcache)
static void	prepare_next_query (SQLFunctionHashEntry *func)
static void	sql_compile_callback (FunctionCallInfo fcinfo, HeapTuple procedureTuple, const CachedFunctionHashKey *hashkey, CachedFunction *cfunc, bool forValidator)
static void	sql_delete_callback (CachedFunction *cfunc)
static void	sql_postrewrite_callback (List *querytree_list, void *arg)
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, SQLFunctionCachePtr fcache)
static void	postquel_sub_params (SQLFunctionCachePtr fcache, FunctionCallInfo fcinfo)
static Datum	postquel_get_single_result (TupleTableSlot *slot, FunctionCallInfo fcinfo, SQLFunctionCachePtr fcache)
static void	sql_compile_error_callback (void *arg)
static void	sql_exec_error_callback (void *arg)
static void	ShutdownSQLFunction (Datum arg)
static void	RemoveSQLFunctionCache (void *arg)
static void	check_sql_fn_statement (List *queryTreeList)
static bool	check_sql_stmt_retval (List *queryTreeList, Oid rettype, TupleDesc rettupdesc, char prokind, bool insertDroppedCols)
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 List *	get_sql_fn_result_tlist (List *queryTreeList)
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 *queryTreeLists)
bool	check_sql_fn_retval (List *queryTreeLists, Oid rettype, TupleDesc rettupdesc, char prokind, bool insertDroppedCols)
DestReceiver *	CreateSQLFunctionDestReceiver (void)

Typedef Documentation

execution_state

typedef struct execution_state execution_state

SQLFunctionCache

typedef struct SQLFunctionCache SQLFunctionCache

SQLFunctionCachePtr

typedef SQLFunctionCache* SQLFunctionCachePtr

Definition at line 190 of file functions.c.

SQLFunctionHashEntry

typedef struct SQLFunctionHashEntry SQLFunctionHashEntry

Enumeration Type Documentation

ExecStatus

enum ExecStatus

Enumerator
F_EXEC_START
F_EXEC_RUN
F_EXEC_DONE

Definition at line 62 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 *	queryTreeLists,
		Oid	rettype,
		TupleDesc	rettupdesc,
		char	prokind,
		bool	insertDroppedCols
	)

Definition at line 2088 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_statement()

static void check_sql_fn_statement ( List *  queryTreeList )

static

Definition at line 2024 of file functions.c.

{
    ListCell   *lc;
 
    foreach(lc, queryTreeList)
    {
        Query      *query = lfirst_node(Query, lc);
 
        /*
         * Disallow calling 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 = (CallStmt *) query->utilityStmt;
 
            if (stmt->outargs != NIL)
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("calling procedures with output arguments is not supported in SQL functions")));
        }
    }
}

References CMD_UTILITY, Query::commandType, ereport, errcode(), errmsg(), ERROR, if(), IsA, lfirst_node, NIL, stmt, and Query::utilityStmt.

Referenced by check_sql_fn_statements(), prepare_next_query(), and sql_postrewrite_callback().

check_sql_fn_statements()

void check_sql_fn_statements

(

List *

queryTreeLists

)

Definition at line 2007 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().

check_sql_stmt_retval()

static bool check_sql_stmt_retval ( List *  queryTreeList, Oid  rettype, TupleDesc  rettupdesc, char  prokind, bool  insertDroppedCols  )

static

Definition at line 2122 of file functions.c.

{
    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;
 
    /*
     * If it's declared to return VOID, we don't care what's in the function.
     * (This takes care of procedures with no output parameters, as well.)
     */
    if (rettype == VOIDOID)
        return false;
 
    /*
     * Find the last canSetTag query in the list of Query nodes.  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/MERGE 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->commandType == CMD_MERGE) &&
             parse->returningList)
    {
        tlist = parse->returningList;
        /* returningList can always be modified */
        tlist_is_modifiable = true;
    }
    else
    {
        /* Last statement is a utility command, or it rewrote to nothing */
        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/MERGE 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 ||
        fn_typtype == TYPTYPE_MULTIRANGE)
    {
        /*
         * 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.
         *
         * We must *not* do this for a procedure, however.  Procedures with
         * output parameter(s) have rettype RECORD, and the CALL code expects
         * to get results corresponding to the list of output parameters, even
         * when there's just one parameter that's composite.
         */
        if (tlistlen == 1 && prokind != PROKIND_PROCEDURE)
        {
            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 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 (!TupleDescCompactAttr(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);
 
        /*
         * Make sure the new query is marked as having row security if the
         * original one does.
         */
        newquery->hasRowSecurity = parse->hasRowSecurity;
 
        /* Replace original query in the correct element of the query list */
        lfirst(parse_cell) = newquery;
    }
 
    return is_tuple_result;
}

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

Referenced by check_sql_fn_retval(), prepare_next_query(), and sql_postrewrite_callback().

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 2492 of file functions.c.

{
    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;
        assign_expr_collations(NULL, cast_result);
        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;
        assign_expr_collations(NULL, cast_result);
        /* 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;
}

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

Referenced by check_sql_stmt_retval().

CreateSQLFunctionDestReceiver()

DestReceiver * CreateSQLFunctionDestReceiver

(

void

)

Definition at line 2589 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 1554 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);
 
    /* 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;
 
    error_context_stack = sqlerrcontext.previous;
 
    return result;
}

References 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().

get_sql_fn_result_tlist()

static List * get_sql_fn_result_tlist ( List *  queryTreeList )

static

Definition at line 2558 of file functions.c.

{
    Query      *parse = NULL;
    ListCell   *lc;
 
    foreach(lc, queryTreeList)
    {
        Query      *q = lfirst_node(Query, lc);
 
        if (q->canSetTag)
            parse = q;
    }
    if (parse &&
        parse->commandType == CMD_SELECT)
        return parse->targetList;
    else if (parse &&
             (parse->commandType == CMD_INSERT ||
              parse->commandType == CMD_UPDATE ||
              parse->commandType == CMD_DELETE ||
              parse->commandType == CMD_MERGE) &&
             parse->returningList)
        return parse->returningList;
    else
        return NIL;
}

References CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, lfirst_node, NIL, and parse().

Referenced by init_execution_state().

init_execution_state()

static bool init_execution_state ( SQLFunctionCachePtr  fcache )

static

Definition at line 629 of file functions.c.

{
    CachedPlanSource *plansource;
    execution_state *preves = NULL;
    execution_state *lasttages = NULL;
    int         nstmts;
    ListCell   *lc;
 
    /*
     * Clean up after previous query, if there was one.
     */
    if (fcache->cplan)
    {
        ReleaseCachedPlan(fcache->cplan, fcache->cowner);
        fcache->cplan = NULL;
    }
    fcache->eslist = NULL;
 
    /*
     * Get the next CachedPlanSource, or stop if there are no more.  We might
     * need to create the next CachedPlanSource; if so, advance
     * error_query_index first, so that errors detected in prepare_next_query
     * are blamed on the right statement.
     */
    if (fcache->next_query_index >= list_length(fcache->func->plansource_list))
    {
        if (fcache->next_query_index >= fcache->func->num_queries)
            return false;
        fcache->error_query_index++;
        prepare_next_query(fcache->func);
    }
    else
        fcache->error_query_index++;
 
    plansource = (CachedPlanSource *) list_nth(fcache->func->plansource_list,
                                               fcache->next_query_index);
    fcache->next_query_index++;
 
    /*
     * Generate plans for the query or queries within this CachedPlanSource.
     * Register the CachedPlan with the current resource owner.  (Saving
     * cowner here is mostly paranoia, but this way we needn't assume that
     * CurrentResourceOwner will be the same when ShutdownSQLFunction runs.)
     */
    fcache->cowner = CurrentResourceOwner;
    fcache->cplan = GetCachedPlan(plansource,
                                  fcache->paramLI,
                                  fcache->cowner,
                                  NULL);
 
    /*
     * If necessary, make esarray[] bigger to hold the needed state.
     */
    nstmts = list_length(fcache->cplan->stmt_list);
    if (nstmts > fcache->esarray_len)
    {
        if (fcache->esarray == NULL)
            fcache->esarray = (execution_state *)
                MemoryContextAlloc(fcache->fcontext,
                                   sizeof(execution_state) * nstmts);
        else
            fcache->esarray = repalloc_array(fcache->esarray,
                                             execution_state, nstmts);
        fcache->esarray_len = nstmts;
    }
 
    /*
     * Build execution_state list to match the number of contained plans.
     */
    foreach(lc, fcache->cplan->stmt_list)
    {
        PlannedStmt *stmt = lfirst_node(PlannedStmt, lc);
        execution_state *newes;
 
        /*
         * 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 an 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 an SQL function",
                                CreateCommandName(stmt->utilityStmt))));
        }
 
        if (fcache->func->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",
                            CreateCommandName((Node *) stmt))));
 
        /* OK, build the execution_state for this query */
        newes = &fcache->esarray[foreach_current_index(lc)];
        if (preves)
            preves->next = newes;
        else
            fcache->eslist = 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 (stmt->canSetTag)
            lasttages = newes;
 
        preves = newes;
    }
 
    /*
     * If this isn't the last CachedPlanSource, we're done here.  Otherwise,
     * we need to prepare information about how to return the results.
     */
    if (fcache->next_query_index < fcache->func->num_queries)
        return true;
 
    /*
     * 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.)
     *
     * Normally we can re-use the JunkFilter across executions, but if the
     * plan for the last CachedPlanSource changed, we'd better rebuild it.
     *
     * The JunkFilter, its result slot, and its tupledesc are kept in a
     * subsidiary memory context so that we can free them easily when needed.
     */
    if (fcache->func->rettype != VOIDOID &&
        (fcache->junkFilter == NULL ||
         fcache->jf_generation != fcache->cplan->generation))
    {
        TupleTableSlot *slot;
        List       *resulttlist;
        MemoryContext oldcontext;
 
        /* Create or reset the jfcontext */
        if (fcache->jfcontext == NULL)
            fcache->jfcontext = AllocSetContextCreate(fcache->fcontext,
                                                      "SQL function junkfilter",
                                                      ALLOCSET_SMALL_SIZES);
        else
            MemoryContextReset(fcache->jfcontext);
        oldcontext = MemoryContextSwitchTo(fcache->jfcontext);
 
        slot = MakeSingleTupleTableSlot(NULL, &TTSOpsMinimalTuple);
 
        /*
         * Re-fetch the (possibly modified) output tlist of the final
         * statement.  By this point, we should have thrown an error if there
         * is not one.
         */
        resulttlist = get_sql_fn_result_tlist(plansource->query_list);
 
        /*
         * 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 (fcache->func->rettupdesc && fcache->func->returnsTuple)
            fcache->junkFilter = ExecInitJunkFilterConversion(resulttlist,
                                                              fcache->func->rettupdesc,
                                                              slot);
        else
            fcache->junkFilter = ExecInitJunkFilter(resulttlist, slot);
 
        /*
         * The resulttlist tree belongs to the plancache and might disappear
         * underneath us due to plancache invalidation.  While we could
         * forestall that by copying it, that'd just be a waste of cycles,
         * because the junkfilter doesn't need it anymore.  (It'd only be used
         * by ExecFindJunkAttribute(), which we don't use here.)  To ensure
         * there's not a dangling pointer laying about, clear the junkFilter's
         * pointer.
         */
        fcache->junkFilter->jf_targetList = NIL;
 
        /* Make sure output rowtype is properly blessed */
        if (fcache->func->returnsTuple)
            BlessTupleDesc(fcache->junkFilter->jf_resultSlot->tts_tupleDescriptor);
 
        /* Mark the JunkFilter as up-to-date */
        fcache->jf_generation = fcache->cplan->generation;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    if (fcache->func->returnsSet &&
        !fcache->func->returnsTuple &&
        type_is_rowtype(fcache->func->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 this might need more work in future.
         */
        fcache->lazyEvalOK = true;
    }
 
    /*
     * 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 (fcache->lazyEvalOK &&
            lasttages->stmt->commandType == CMD_SELECT &&
            !lasttages->stmt->hasModifyingCTE)
            fcache->lazyEval = lasttages->lazyEval = true;
    }
 
    return true;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, BlessTupleDesc(), CMD_SELECT, CMD_UTILITY, CommandIsReadOnly(), PlannedStmt::commandType, SQLFunctionCache::cowner, SQLFunctionCache::cplan, CreateCommandName(), CurrentResourceOwner, ereport, errcode(), errmsg(), ERROR, SQLFunctionCache::error_query_index, SQLFunctionCache::esarray, SQLFunctionCache::esarray_len, SQLFunctionCache::eslist, ExecInitJunkFilter(), ExecInitJunkFilterConversion(), F_EXEC_START, SQLFunctionCache::fcontext, foreach_current_index, SQLFunctionCache::func, CachedPlan::generation, get_sql_fn_result_tlist(), GetCachedPlan(), PlannedStmt::hasModifyingCTE, IsA, SQLFunctionCache::jf_generation, JunkFilter::jf_resultSlot, JunkFilter::jf_targetList, SQLFunctionCache::jfcontext, SQLFunctionCache::junkFilter, execution_state::lazyEval, SQLFunctionCache::lazyEval, SQLFunctionCache::lazyEvalOK, lfirst_node, list_length(), list_nth(), MakeSingleTupleTableSlot(), MemoryContextAlloc(), MemoryContextReset(), MemoryContextSwitchTo(), execution_state::next, SQLFunctionCache::next_query_index, NIL, SQLFunctionHashEntry::num_queries, SQLFunctionCache::paramLI, SQLFunctionHashEntry::plansource_list, prepare_next_query(), execution_state::qd, CachedPlanSource::query_list, SQLFunctionHashEntry::readonly_func, ReleaseCachedPlan(), repalloc_array, SQLFunctionHashEntry::rettupdesc, SQLFunctionHashEntry::rettype, SQLFunctionHashEntry::returnsSet, SQLFunctionHashEntry::returnsTuple, execution_state::setsResult, execution_state::status, execution_state::stmt, stmt, CachedPlan::stmt_list, TupleTableSlot::tts_tupleDescriptor, TTSOpsMinimalTuple, and type_is_rowtype().

Referenced by fmgr_sql().

init_sql_fcache()

static SQLFunctionCache * init_sql_fcache ( FunctionCallInfo  fcinfo, bool  lazyEvalOK  )

static

Definition at line 534 of file functions.c.

{
    FmgrInfo   *finfo = fcinfo->flinfo;
    SQLFunctionHashEntry *func;
    SQLFunctionCache *fcache;
 
    /*
     * If this is the first execution for this FmgrInfo, set up a cache struct
     * (initially containing null pointers).  The cache must live as long as
     * the FmgrInfo, so it goes in fn_mcxt.  Also set up a memory context
     * callback that will be invoked when fn_mcxt is deleted.
     */
    fcache = finfo->fn_extra;
    if (fcache == NULL)
    {
        fcache = (SQLFunctionCache *)
            MemoryContextAllocZero(finfo->fn_mcxt, sizeof(SQLFunctionCache));
        fcache->fcontext = finfo->fn_mcxt;
        fcache->mcb.func = RemoveSQLFunctionCache;
        fcache->mcb.arg = fcache;
        MemoryContextRegisterResetCallback(finfo->fn_mcxt, &fcache->mcb);
        finfo->fn_extra = fcache;
    }
 
    /*
     * If we are resuming execution of a set-returning function, just keep
     * using the same cache.  We do not ask funccache.c to re-validate the
     * SQLFunctionHashEntry: we want to run to completion using the function's
     * initial definition.
     */
    if (fcache->eslist != NULL)
    {
        Assert(fcache->func != NULL);
        return fcache;
    }
 
    /*
     * Look up, or re-validate, the long-lived hash entry.  Make the hash key
     * depend on the result of get_call_result_type() when that's composite,
     * so that we can safely assume that we'll build a new hash entry if the
     * composite rowtype changes.
     */
    func = (SQLFunctionHashEntry *)
        cached_function_compile(fcinfo,
                                (CachedFunction *) fcache->func,
                                sql_compile_callback,
                                sql_delete_callback,
                                sizeof(SQLFunctionHashEntry),
                                true,
                                false);
 
    /*
     * Install the hash pointer in the SQLFunctionCache, and increment its use
     * count to reflect that.  If cached_function_compile gave us back a
     * different hash entry than we were using before, we must decrement that
     * one's use count.
     */
    if (func != fcache->func)
    {
        if (fcache->func != NULL)
        {
            Assert(fcache->func->cfunc.use_count > 0);
            fcache->func->cfunc.use_count--;
        }
        fcache->func = func;
        func->cfunc.use_count++;
        /* Assume we need to rebuild the junkFilter */
        fcache->junkFilter = NULL;
    }
 
    /*
     * We're beginning a new execution of the function, so convert params to
     * appropriate format.
     */
    postquel_sub_params(fcache, fcinfo);
 
    /* Also reset lazyEval state for the new execution. */
    fcache->lazyEvalOK = lazyEvalOK;
    fcache->lazyEval = false;
 
    /* Also reset data about where we are in the function. */
    fcache->eslist = NULL;
    fcache->next_query_index = 0;
    fcache->error_query_index = 0;
 
    return fcache;
}

References MemoryContextCallback::arg, Assert(), cached_function_compile(), SQLFunctionHashEntry::cfunc, SQLFunctionCache::error_query_index, SQLFunctionCache::eslist, SQLFunctionCache::fcontext, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, SQLFunctionCache::func, MemoryContextCallback::func, SQLFunctionCache::junkFilter, SQLFunctionCache::lazyEval, SQLFunctionCache::lazyEvalOK, SQLFunctionCache::mcb, MemoryContextAllocZero(), MemoryContextRegisterResetCallback(), SQLFunctionCache::next_query_index, postquel_sub_params(), RemoveSQLFunctionCache(), sql_compile_callback(), sql_delete_callback(), and CachedFunction::use_count.

Referenced by fmgr_sql().

postquel_end()

static void postquel_end ( execution_state *  es, SQLFunctionCachePtr  fcache  )

static

Definition at line 1419 of file functions.c.

{
    MemoryContext oldcontext;
 
    /* Run the sub-executor in subcontext */
    oldcontext = MemoryContextSwitchTo(fcache->subcontext);
 
    /* 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;
 
    MemoryContextSwitchTo(oldcontext);
 
    /* Delete the subcontext, if it's actually a separate context */
    if (fcache->ownSubcontext)
        MemoryContextDelete(fcache->subcontext);
    fcache->subcontext = NULL;
}

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

Referenced by fmgr_sql(), and ShutdownSQLFunction().

postquel_get_single_result()

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

static

Definition at line 1514 of file functions.c.

{
    Datum       value;
 
    /*
     * Set up to return the function value.  For pass-by-reference datatypes,
     * be sure to copy the result into the current context.  We can't leave
     * the data in the TupleTableSlot because we must clear the slot before
     * returning.
     */
    if (fcache->func->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 current context if needed.
         */
        value = slot_getattr(slot, 1, &(fcinfo->isnull));
 
        if (!fcinfo->isnull)
            value = datumCopy(value, fcache->func->typbyval, fcache->func->typlen);
    }
 
    /* Clear the slot for next time */
    ExecClearTuple(slot);
 
    return value;
}

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

Referenced by fmgr_sql().

postquel_getnext()

static bool postquel_getnext ( execution_state *  es, SQLFunctionCachePtr  fcache  )

static

Definition at line 1378 of file functions.c.

{
    bool        result;
    MemoryContext oldcontext;
 
    /* Run the sub-executor in subcontext */
    oldcontext = MemoryContextSwitchTo(fcache->subcontext);
 
    if (es->qd->operation == CMD_UTILITY)
    {
        ProcessUtility(es->qd->plannedstmt,
                       fcache->func->src,
                       true,    /* protect function cache's parsetree */
                       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);
 
        /*
         * 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);
    }
 
    MemoryContextSwitchTo(oldcontext);
 
    return result;
}

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

Referenced by fmgr_sql().

postquel_start()

static void postquel_start ( execution_state *  es, SQLFunctionCachePtr  fcache  )

static

Definition at line 1252 of file functions.c.

{
    DestReceiver *dest;
    MemoryContext oldcontext = CurrentMemoryContext;
 
    Assert(es->qd == NULL);
 
    /* Caller should have ensured a suitable snapshot is active */
    Assert(ActiveSnapshotSet());
 
    /*
     * In lazyEval mode for a SRF, we must run the sub-executor in a child of
     * fcontext, so that it can survive across multiple calls to fmgr_sql.
     * (XXX in the case of a long-lived FmgrInfo, this policy potentially
     * causes memory leakage, but it's not very clear where we could keep
     * stuff instead.  Fortunately, there are few if any cases where
     * set-returning functions are invoked via FmgrInfos that would outlive
     * the calling query.)  Otherwise, we're going to run it to completion
     * before exiting fmgr_sql, so it can perfectly well run in the caller's
     * context.
     */
    if (es->lazyEval && fcache->func->returnsSet)
    {
        fcache->subcontext = AllocSetContextCreate(fcache->fcontext,
                                                   "SQL function execution",
                                                   ALLOCSET_DEFAULT_SIZES);
        fcache->ownSubcontext = true;
    }
    else if (es->stmt->commandType == CMD_UTILITY)
    {
        /*
         * The code path using a sub-executor is pretty good about cleaning up
         * cruft, since the executor will make its own sub-context.  We don't
         * really need an additional layer of sub-context in that case.
         * However, if this is a utility statement, it won't make its own
         * sub-context, so it seems advisable to make one that we can free on
         * completion.
         */
        fcache->subcontext = AllocSetContextCreate(CurrentMemoryContext,
                                                   "SQL function execution",
                                                   ALLOCSET_DEFAULT_SIZES);
        fcache->ownSubcontext = true;
    }
    else
    {
        fcache->subcontext = CurrentMemoryContext;
        fcache->ownSubcontext = false;
    }
 
    /*
     * Build a tuplestore if needed, that is if it's a set-returning function
     * and we're producing the function result without using lazyEval mode.
     */
    if (es->setsResult)
    {
        Assert(fcache->tstore == NULL);
        if (fcache->func->returnsSet && !es->lazyEval)
        {
            MemoryContextSwitchTo(fcache->tscontext);
            fcache->tstore = tuplestore_begin_heap(fcache->randomAccess,
                                                   false, work_mem);
        }
    }
 
    /* Switch into the selected subcontext (might be a no-op) */
    MemoryContextSwitchTo(fcache->subcontext);
 
    /*
     * If this query produces the function result, collect its output using
     * our custom DestReceiver; 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;   /* might be NULL */
        myState->filter = fcache->junkFilter;
 
        /* Make very sure the junkfilter's result slot is empty */
        ExecClearTuple(fcache->junkFilter->jf_resultSlot);
    }
    else
        dest = None_Receiver;
 
    es->qd = CreateQueryDesc(es->stmt,
                             NULL,
                             fcache->func->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 */
        if (!ExecutorStart(es->qd, eflags))
            elog(ERROR, "ExecutorStart() failed unexpectedly");
    }
 
    es->status = F_EXEC_RUN;
 
    MemoryContextSwitchTo(oldcontext);
}

References ActiveSnapshotSet(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CMD_UTILITY, PlannedStmt::commandType, CreateDestReceiver(), CreateQueryDesc(), CurrentMemoryContext, generate_unaccent_rules::dest, DestSQLFunction, elog, ERROR, EXEC_FLAG_SKIP_TRIGGERS, ExecClearTuple(), ExecutorStart(), F_EXEC_RUN, SQLFunctionCache::fcontext, DR_sqlfunction::filter, SQLFunctionCache::func, GetActiveSnapshot(), InvalidSnapshot, JunkFilter::jf_resultSlot, SQLFunctionCache::junkFilter, execution_state::lazyEval, MemoryContextSwitchTo(), _DestReceiver::mydest, None_Receiver, QueryDesc::operation, SQLFunctionCache::ownSubcontext, SQLFunctionCache::paramLI, DR_sqlfunction::pub, execution_state::qd, QueryDesc::queryEnv, SQLFunctionCache::randomAccess, SQLFunctionHashEntry::returnsSet, execution_state::setsResult, SQLFunctionHashEntry::src, execution_state::status, execution_state::stmt, SQLFunctionCache::subcontext, SQLFunctionCache::tscontext, DR_sqlfunction::tstore, SQLFunctionCache::tstore, tuplestore_begin_heap(), and work_mem.

Referenced by fmgr_sql().

postquel_sub_params()

static void postquel_sub_params ( SQLFunctionCachePtr  fcache, FunctionCallInfo  fcinfo  )

static

Definition at line 1451 of file functions.c.

{
    int         nargs = fcinfo->nargs;
 
    if (nargs > 0)
    {
        ParamListInfo paramLI;
        Oid        *argtypes = fcache->func->pinfo->argtypes;
        int16      *argtyplen = fcache->func->argtyplen;
 
        if (fcache->paramLI == NULL)
        {
            /* First time through: build a persistent ParamListInfo struct */
            MemoryContext oldcontext;
 
            oldcontext = MemoryContextSwitchTo(fcache->fcontext);
            paramLI = makeParamList(nargs);
            fcache->paramLI = paramLI;
            MemoryContextSwitchTo(oldcontext);
        }
        else
        {
            paramLI = fcache->paramLI;
            Assert(paramLI->numParams == nargs);
        }
 
        for (int i = 0; i < nargs; i++)
        {
            ParamExternData *prm = &paramLI->params[i];
 
            /*
             * If an incoming parameter value is a R/W expanded datum, we
             * force it to R/O.  We'd be perfectly entitled to scribble on it,
             * but the problem is that if the parameter is referenced more
             * than once in the function, earlier references might mutate the
             * value seen by later references, which won't do at all.  We
             * could do better if we could be sure of the number of Param
             * nodes in the function's plans; but we might not have planned
             * all the statements yet, nor do we have plan tree walker
             * infrastructure.  (Examining the parse trees is not good enough,
             * because of possible function inlining during planning.)
             */
            prm->isnull = fcinfo->args[i].isnull;
            prm->value = MakeExpandedObjectReadOnly(fcinfo->args[i].value,
                                                    prm->isnull,
                                                    argtyplen[i]);
            /* Allow the value to be substituted into custom plans */
            prm->pflags = PARAM_FLAG_CONST;
            prm->ptype = argtypes[i];
        }
    }
    else
        fcache->paramLI = NULL;
}

References FunctionCallInfoBaseData::args, SQLFunctionParseInfo::argtypes, SQLFunctionHashEntry::argtyplen, Assert(), SQLFunctionCache::fcontext, SQLFunctionCache::func, i, ParamExternData::isnull, NullableDatum::isnull, MakeExpandedObjectReadOnly, makeParamList(), MemoryContextSwitchTo(), FunctionCallInfoBaseData::nargs, ParamListInfoData::numParams, PARAM_FLAG_CONST, SQLFunctionCache::paramLI, ParamListInfoData::params, ParamExternData::pflags, SQLFunctionHashEntry::pinfo, ParamExternData::ptype, ParamExternData::value, and NullableDatum::value.

Referenced by init_sql_fcache().

prepare_next_query()

static void prepare_next_query ( SQLFunctionHashEntry *  func )

static

Definition at line 876 of file functions.c.

{
    int         qindex;
    bool        islast;
    CachedPlanSource *plansource;
    List       *queryTree_list;
    MemoryContext oldcontext;
 
    /* Which query should we process? */
    qindex = list_length(func->plansource_list);
    Assert(qindex < func->num_queries); /* else caller error */
    islast = (qindex + 1 >= func->num_queries);
 
    /*
     * Parse and/or rewrite the query, creating a CachedPlanSource that holds
     * a copy of the original parsetree.  Note fine point: we make a copy of
     * each original parsetree to ensure that the source_list in pcontext
     * remains unmodified during parse analysis and rewrite.  This is normally
     * unnecessary, but we have to do it in case an error is raised during
     * parse analysis.  Otherwise, a fresh attempt to execute the function
     * will arrive back here and try to work from a corrupted source_list.
     */
    if (!func->raw_source)
    {
        /* Source queries are already parse-analyzed */
        Query      *parsetree = list_nth_node(Query, func->source_list, qindex);
 
        parsetree = copyObject(parsetree);
        plansource = CreateCachedPlanForQuery(parsetree,
                                              func->src,
                                              CreateCommandTag((Node *) parsetree));
        AcquireRewriteLocks(parsetree, true, false);
        queryTree_list = pg_rewrite_query(parsetree);
    }
    else
    {
        /* Source queries are raw parsetrees */
        RawStmt    *parsetree = list_nth_node(RawStmt, func->source_list, qindex);
 
        parsetree = copyObject(parsetree);
        plansource = CreateCachedPlan(parsetree,
                                      func->src,
                                      CreateCommandTag(parsetree->stmt));
        queryTree_list = pg_analyze_and_rewrite_withcb(parsetree,
                                                       func->src,
                                                       (ParserSetupHook) sql_fn_parser_setup,
                                                       func->pinfo,
                                                       NULL);
    }
 
    /*
     * Check that there are no statements we don't want to allow.
     */
    check_sql_fn_statement(queryTree_list);
 
    /*
     * If this is the last query, 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_stmt_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 func->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.)
     */
    if (islast)
        func->returnsTuple = check_sql_stmt_retval(queryTree_list,
                                                   func->rettype,
                                                   func->rettupdesc,
                                                   func->prokind,
                                                   false);
 
    /*
     * Now that check_sql_stmt_retval has done its thing, we can complete plan
     * cache entry creation.
     */
    CompleteCachedPlan(plansource,
                       queryTree_list,
                       NULL,
                       NULL,
                       0,
                       (ParserSetupHook) sql_fn_parser_setup,
                       func->pinfo,
                       CURSOR_OPT_PARALLEL_OK | CURSOR_OPT_NO_SCROLL,
                       false);
 
    /*
     * Install post-rewrite hook.  Its arg is the hash entry if this is the
     * last statement, else NULL.
     */
    SetPostRewriteHook(plansource,
                       sql_postrewrite_callback,
                       islast ? func : NULL);
 
    /*
     * While the CachedPlanSources can take care of themselves, our List
     * pointing to them had better be in the hcontext.
     */
    oldcontext = MemoryContextSwitchTo(func->hcontext);
    func->plansource_list = lappend(func->plansource_list, plansource);
    MemoryContextSwitchTo(oldcontext);
 
    /*
     * As soon as we've linked the CachedPlanSource into the list, mark it as
     * "saved".
     */
    SaveCachedPlan(plansource);
 
    /*
     * Finally, if this was the last statement, we can flush the pcontext with
     * the original query trees; they're all safely copied into
     * CachedPlanSources now.
     */
    if (islast)
    {
        func->source_list = NIL;    /* avoid dangling pointer */
        MemoryContextDelete(func->pcontext);
        func->pcontext = NULL;
    }
}

References AcquireRewriteLocks(), Assert(), check_sql_fn_statement(), check_sql_stmt_retval(), CompleteCachedPlan(), copyObject, CreateCachedPlan(), CreateCachedPlanForQuery(), CreateCommandTag(), CURSOR_OPT_NO_SCROLL, CURSOR_OPT_PARALLEL_OK, SQLFunctionHashEntry::hcontext, lappend(), list_length(), list_nth_node, MemoryContextDelete(), MemoryContextSwitchTo(), NIL, SQLFunctionHashEntry::num_queries, SQLFunctionHashEntry::pcontext, pg_analyze_and_rewrite_withcb(), pg_rewrite_query(), SQLFunctionHashEntry::pinfo, SQLFunctionHashEntry::plansource_list, SQLFunctionHashEntry::prokind, SQLFunctionHashEntry::raw_source, SQLFunctionHashEntry::rettupdesc, SQLFunctionHashEntry::rettype, SQLFunctionHashEntry::returnsTuple, SaveCachedPlan(), SetPostRewriteHook(), SQLFunctionHashEntry::source_list, sql_fn_parser_setup(), sql_postrewrite_callback(), SQLFunctionHashEntry::src, and RawStmt::stmt.

Referenced by init_execution_state().

prepare_sql_fn_parse_info()

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

Definition at line 249 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().

RemoveSQLFunctionCache()

static void RemoveSQLFunctionCache ( void *  arg )

static

Definition at line 1986 of file functions.c.

{
    SQLFunctionCache *fcache = (SQLFunctionCache *) arg;
 
    /* Release reference count on SQLFunctionHashEntry */
    if (fcache->func != NULL)
    {
        Assert(fcache->func->cfunc.use_count > 0);
        fcache->func->cfunc.use_count--;
        /* This should be unnecessary, but let's just be sure: */
        fcache->func = NULL;
    }
}

References arg, Assert(), SQLFunctionHashEntry::cfunc, SQLFunctionCache::func, and CachedFunction::use_count.

Referenced by init_sql_fcache().

ShutdownSQLFunction()

static void ShutdownSQLFunction ( Datum  arg )

static

Definition at line 1939 of file functions.c.

{
    SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) DatumGetPointer(arg);
    execution_state *es;
 
    es = fcache->eslist;
    while (es)
    {
        /* Shut down anything still running */
        if (es->status == F_EXEC_RUN)
        {
            /* Re-establish active snapshot for any called functions */
            if (!fcache->func->readonly_func)
                PushActiveSnapshot(es->qd->snapshot);
 
            postquel_end(es, fcache);
 
            if (!fcache->func->readonly_func)
                PopActiveSnapshot();
        }
        es = es->next;
    }
    fcache->eslist = NULL;
 
    /* Release tuplestore if we have one */
    if (fcache->tstore)
        tuplestore_end(fcache->tstore);
    fcache->tstore = NULL;
 
    /* Release CachedPlan if we have one */
    if (fcache->cplan)
        ReleaseCachedPlan(fcache->cplan, fcache->cowner);
    fcache->cplan = NULL;
 
    /* execUtils will deregister the callback... */
    fcache->shutdown_reg = false;
}

References arg, SQLFunctionCache::cowner, SQLFunctionCache::cplan, DatumGetPointer(), SQLFunctionCache::eslist, F_EXEC_RUN, SQLFunctionCache::func, execution_state::next, PopActiveSnapshot(), postquel_end(), PushActiveSnapshot(), execution_state::qd, SQLFunctionHashEntry::readonly_func, ReleaseCachedPlan(), SQLFunctionCache::shutdown_reg, QueryDesc::snapshot, execution_state::status, SQLFunctionCache::tstore, and tuplestore_end().

Referenced by fmgr_sql().

sql_compile_callback()

static void sql_compile_callback ( FunctionCallInfo  fcinfo, HeapTuple  procedureTuple, const CachedFunctionHashKey *  hashkey, CachedFunction *  cfunc, bool  forValidator  )

static

Definition at line 1016 of file functions.c.

{
    SQLFunctionHashEntry *func = (SQLFunctionHashEntry *) cfunc;
    Form_pg_proc procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
    ErrorContextCallback comperrcontext;
    MemoryContext hcontext;
    MemoryContext pcontext;
    MemoryContext oldcontext = CurrentMemoryContext;
    Oid         rettype;
    TupleDesc   rettupdesc;
    Datum       tmp;
    bool        isNull;
    List       *source_list;
 
    /*
     * Setup error traceback support for ereport() during compile.  (This is
     * mainly useful for reporting parse errors from pg_parse_query.)
     */
    comperrcontext.callback = sql_compile_error_callback;
    comperrcontext.arg = func;
    comperrcontext.previous = error_context_stack;
    error_context_stack = &comperrcontext;
 
    /*
     * Create the hash entry's memory context.  For now it's a child of the
     * caller's context, so that it will go away if we fail partway through.
     */
    hcontext = AllocSetContextCreate(CurrentMemoryContext,
                                     "SQL function",
                                     ALLOCSET_SMALL_SIZES);
 
    /*
     * Create the not-as-long-lived pcontext.  We make this a child of
     * hcontext so that it doesn't require separate deletion.
     */
    pcontext = AllocSetContextCreate(hcontext,
                                     "SQL function parse trees",
                                     ALLOCSET_SMALL_SIZES);
    func->pcontext = pcontext;
 
    /*
     * copy function name immediately for use by error reporting callback, and
     * for use as memory context identifier
     */
    func->fname = MemoryContextStrdup(hcontext,
                                      NameStr(procedureStruct->proname));
    MemoryContextSetIdentifier(hcontext, func->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);
 
    func->rettype = rettype;
    if (rettupdesc)
    {
        MemoryContextSwitchTo(hcontext);
        func->rettupdesc = CreateTupleDescCopy(rettupdesc);
        MemoryContextSwitchTo(oldcontext);
    }
 
    /* Fetch the typlen and byval info for the result type */
    get_typlenbyval(rettype, &func->typlen, &func->typbyval);
 
    /* Remember whether we're returning setof something */
    func->returnsSet = procedureStruct->proretset;
 
    /* Remember if function is STABLE/IMMUTABLE */
    func->readonly_func =
        (procedureStruct->provolatile != PROVOLATILE_VOLATILE);
 
    /* Remember routine kind */
    func->prokind = procedureStruct->prokind;
 
    /*
     * 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.
     */
    MemoryContextSwitchTo(hcontext);
    func->pinfo = prepare_sql_fn_parse_info(procedureTuple,
                                            fcinfo->flinfo->fn_expr,
                                            PG_GET_COLLATION());
    MemoryContextSwitchTo(oldcontext);
 
    /*
     * Now that we have the resolved argument types, collect their typlens for
     * use in postquel_sub_params.
     */
    func->argtyplen = (int16 *)
        MemoryContextAlloc(hcontext, func->pinfo->nargs * sizeof(int16));
    for (int i = 0; i < func->pinfo->nargs; i++)
        func->argtyplen[i] = get_typlen(func->pinfo->argtypes[i]);
 
    /*
     * And of course we need the function body text.
     */
    tmp = SysCacheGetAttrNotNull(PROCOID, procedureTuple, Anum_pg_proc_prosrc);
    func->src = MemoryContextStrdup(hcontext,
                                    TextDatumGetCString(tmp));
 
    /* If we have prosqlbody, pay attention to that not prosrc. */
    tmp = SysCacheGetAttr(PROCOID,
                          procedureTuple,
                          Anum_pg_proc_prosqlbody,
                          &isNull);
    if (!isNull)
    {
        /* Source queries are already parse-analyzed */
        Node       *n;
 
        n = stringToNode(TextDatumGetCString(tmp));
        if (IsA(n, List))
            source_list = linitial_node(List, castNode(List, n));
        else
            source_list = list_make1(n);
        func->raw_source = false;
    }
    else
    {
        /* Source queries are raw parsetrees */
        source_list = pg_parse_query(func->src);
        func->raw_source = true;
    }
 
    /*
     * Note: we must save the number of queries so that we'll still remember
     * how many there are after we discard source_list.
     */
    func->num_queries = list_length(source_list);
 
    /*
     * Edge case: empty function body is OK only if it returns VOID.  Normally
     * we validate that the last statement returns the right thing in
     * check_sql_stmt_retval, but we'll never reach that if there's no last
     * statement.
     */
    if (func->num_queries == 0 && rettype != VOIDOID)
        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/MERGE RETURNING.")));
 
    /* Save the source trees in pcontext for now. */
    MemoryContextSwitchTo(pcontext);
    func->source_list = copyObject(source_list);
    MemoryContextSwitchTo(oldcontext);
 
    /*
     * We now have a fully valid hash entry, so reparent hcontext under
     * CacheMemoryContext to make all the subsidiary data long-lived, and only
     * then install the hcontext link so that sql_delete_callback will know to
     * delete it.
     */
    MemoryContextSetParent(hcontext, CacheMemoryContext);
    func->hcontext = hcontext;
 
    error_context_stack = comperrcontext.previous;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, ErrorContextCallback::arg, SQLFunctionParseInfo::argtypes, SQLFunctionHashEntry::argtyplen, CacheMemoryContext, ErrorContextCallback::callback, castNode, copyObject, CreateTupleDescCopy(), CurrentMemoryContext, ereport, errcode(), errdetail(), errmsg(), ERROR, error_context_stack, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_expr, SQLFunctionHashEntry::fname, format_type_be(), get_call_result_type(), get_typlen(), get_typlenbyval(), GETSTRUCT(), SQLFunctionHashEntry::hcontext, i, IsA, linitial_node, list_length(), list_make1, MemoryContextAlloc(), MemoryContextSetIdentifier(), MemoryContextSetParent(), MemoryContextStrdup(), MemoryContextSwitchTo(), NameStr, SQLFunctionParseInfo::nargs, SQLFunctionHashEntry::num_queries, SQLFunctionHashEntry::pcontext, PG_GET_COLLATION, pg_parse_query(), SQLFunctionHashEntry::pinfo, prepare_sql_fn_parse_info(), ErrorContextCallback::previous, SQLFunctionHashEntry::prokind, SQLFunctionHashEntry::raw_source, SQLFunctionHashEntry::readonly_func, SQLFunctionHashEntry::rettupdesc, SQLFunctionHashEntry::rettype, SQLFunctionHashEntry::returnsSet, SQLFunctionHashEntry::source_list, sql_compile_error_callback(), SQLFunctionHashEntry::src, stringToNode(), SysCacheGetAttr(), SysCacheGetAttrNotNull(), TextDatumGetCString, SQLFunctionHashEntry::typbyval, and SQLFunctionHashEntry::typlen.

Referenced by init_sql_fcache().

sql_compile_error_callback()

static void sql_compile_error_callback ( void *  arg )

static

Definition at line 1867 of file functions.c.

{
    SQLFunctionHashEntry *func = (SQLFunctionHashEntry *) arg;
    int         syntaxerrposition;
 
    /*
     * We can do nothing useful if sql_compile_callback() didn't get as far as
     * copying the function name
     */
    if (func->fname == NULL)
        return;
 
    /*
     * If there is a syntax error position, convert to internal syntax error
     */
    syntaxerrposition = geterrposition();
    if (syntaxerrposition > 0 && func->src != NULL)
    {
        errposition(0);
        internalerrposition(syntaxerrposition);
        internalerrquery(func->src);
    }
 
    /*
     * sql_compile_callback() doesn't do any per-query processing, so just
     * report the context as "during startup".
     */
    errcontext("SQL function \"%s\" during startup", func->fname);
}

References arg, errcontext, errposition(), SQLFunctionHashEntry::fname, geterrposition(), internalerrposition(), internalerrquery(), and SQLFunctionHashEntry::src.

Referenced by sql_compile_callback().

sql_delete_callback()

static void sql_delete_callback ( CachedFunction *  cfunc )

static

Definition at line 1189 of file functions.c.

{
    SQLFunctionHashEntry *func = (SQLFunctionHashEntry *) cfunc;
    ListCell   *lc;
 
    /* Release the CachedPlanSources */
    foreach(lc, func->plansource_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
 
        DropCachedPlan(plansource);
    }
    func->plansource_list = NIL;
 
    /*
     * If we have an hcontext, free it, thereby getting rid of all subsidiary
     * data.  (If we still have a pcontext, this gets rid of that too.)
     */
    if (func->hcontext)
        MemoryContextDelete(func->hcontext);
    func->hcontext = NULL;
}

References DropCachedPlan(), SQLFunctionHashEntry::hcontext, lfirst, MemoryContextDelete(), NIL, and SQLFunctionHashEntry::plansource_list.

Referenced by init_sql_fcache().

sql_exec_error_callback()

static void sql_exec_error_callback ( void *  arg )

static

Definition at line 1901 of file functions.c.

{
    SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) arg;
    int         syntaxerrposition;
 
    /*
     * If there is a syntax error position, convert to internal syntax error
     */
    syntaxerrposition = geterrposition();
    if (syntaxerrposition > 0 && fcache->func->src != NULL)
    {
        errposition(0);
        internalerrposition(syntaxerrposition);
        internalerrquery(fcache->func->src);
    }
 
    /*
     * If we failed while executing an identifiable query within the function,
     * report that.  Otherwise say it was "during startup".
     */
    if (fcache->error_query_index > 0)
        errcontext("SQL function \"%s\" statement %d",
                   fcache->func->fname, fcache->error_query_index);
    else
        errcontext("SQL function \"%s\" during startup", fcache->func->fname);
}

References arg, errcontext, SQLFunctionCache::error_query_index, errposition(), SQLFunctionHashEntry::fname, SQLFunctionCache::func, geterrposition(), internalerrposition(), internalerrquery(), and SQLFunctionHashEntry::src.

Referenced by fmgr_sql().

sql_fn_make_param()

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

static

Definition at line 483 of file functions.c.

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

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

Referenced by sql_fn_param_ref(), and sql_fn_resolve_param_name().

sql_fn_param_ref()

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

static

Definition at line 467 of file functions.c.

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

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

Referenced by sql_fn_parser_setup().

sql_fn_parser_setup()

void sql_fn_parser_setup	(	struct ParseState *	pstate,
		SQLFunctionParseInfoPtr	pinfo
	)

Definition at line 338 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().

sql_fn_post_column_ref()

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

static

Definition at line 351 of file functions.c.

{
    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);
    name1 = strVal(field1);
    if (nnames > 1)
    {
        subfield = (Node *) lsecond(cref->fields);
        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;
}

References Assert(), ColumnRef::fields, SQLFunctionParseInfo::fname, if(), 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().

sql_fn_resolve_param_name()

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

static

Definition at line 513 of file functions.c.

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

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

Referenced by sql_fn_post_column_ref().

sql_postrewrite_callback()

static void sql_postrewrite_callback ( List *  querytree_list, void *  arg  )

static

Definition at line 1219 of file functions.c.

{
    /*
     * Check that there are no statements we don't want to allow.  (Presently,
     * there's no real point in this because the result can't change from what
     * we saw originally.  But it's cheap and maybe someday it will matter.)
     */
    check_sql_fn_statement(querytree_list);
 
    /*
     * If this is the last query, we must re-do what check_sql_stmt_retval did
     * to its targetlist.  Also check that returnsTuple didn't change (it
     * probably cannot, but be cautious).
     */
    if (arg != NULL)
    {
        SQLFunctionHashEntry *func = (SQLFunctionHashEntry *) arg;
        bool        returnsTuple;
 
        returnsTuple = check_sql_stmt_retval(querytree_list,
                                             func->rettype,
                                             func->rettupdesc,
                                             func->prokind,
                                             false);
        if (returnsTuple != func->returnsTuple)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cached plan must not change result type")));
    }
}

References arg, check_sql_fn_statement(), check_sql_stmt_retval(), ereport, errcode(), errmsg(), ERROR, SQLFunctionHashEntry::prokind, SQLFunctionHashEntry::rettupdesc, SQLFunctionHashEntry::rettype, and SQLFunctionHashEntry::returnsTuple.

Referenced by prepare_next_query().

sqlfunction_destroy()

static void sqlfunction_destroy ( DestReceiver *  self )

static

Definition at line 2664 of file functions.c.

{
    pfree(self);
}

References pfree().

Referenced by CreateSQLFunctionDestReceiver().

sqlfunction_receive()

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

static

Definition at line 2617 of file functions.c.

{
    DR_sqlfunction *myState = (DR_sqlfunction *) self;
 
    if (myState->tstore)
    {
        /* We are collecting all of a set result into the tuplestore */
 
        /* Filter tuple as needed */
        slot = ExecFilterJunk(myState->filter, slot);
 
        /* Store the filtered tuple into the tuplestore */
        tuplestore_puttupleslot(myState->tstore, slot);
    }
    else
    {
        /*
         * We only want the first tuple, which we'll save in the junkfilter's
         * result slot.  Ignore any additional tuples passed.
         */
        if (TTS_EMPTY(myState->filter->jf_resultSlot))
        {
            /* Filter tuple as needed */
            slot = ExecFilterJunk(myState->filter, slot);
            Assert(slot == myState->filter->jf_resultSlot);
 
            /* Materialize the slot so it preserves pass-by-ref values */
            ExecMaterializeSlot(slot);
        }
    }
 
    return true;
}

References Assert(), ExecFilterJunk(), ExecMaterializeSlot(), DR_sqlfunction::filter, JunkFilter::jf_resultSlot, DR_sqlfunction::tstore, TTS_EMPTY, and tuplestore_puttupleslot().

Referenced by CreateSQLFunctionDestReceiver().

sqlfunction_shutdown()

static void sqlfunction_shutdown ( DestReceiver *  self )

static

Definition at line 2655 of file functions.c.

{
    /* no-op */
}

Referenced by CreateSQLFunctionDestReceiver().

sqlfunction_startup()

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

static

Definition at line 2608 of file functions.c.

{
    /* no-op */
}

Referenced by CreateSQLFunctionDestReceiver().