spi.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/printtup.h"
#include "access/sysattr.h"
#include "access/xact.h"
#include "catalog/heap.h"
#include "catalog/pg_type.h"
#include "commands/trigger.h"
#include "executor/executor.h"
#include "executor/spi_priv.h"
#include "miscadmin.h"
#include "tcop/pquery.h"
#include "tcop/utility.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for spi.c:

Go to the source code of this file.

Data Structures
struct	SPICallbackArg

Typedefs
typedef struct SPICallbackArg	SPICallbackArg

Functions
static Portal	SPI_cursor_open_internal (const char *name, SPIPlanPtr plan, ParamListInfo paramLI, bool read_only)
static void	_SPI_prepare_plan (const char *src, SPIPlanPtr plan)
static void	_SPI_prepare_oneshot_plan (const char *src, SPIPlanPtr plan)
static int	_SPI_execute_plan (SPIPlanPtr plan, const SPIExecuteOptions *options, Snapshot snapshot, Snapshot crosscheck_snapshot, bool fire_triggers)
static ParamListInfo	_SPI_convert_params (int nargs, Oid *argtypes, Datum *Values, const char *Nulls)
static int	_SPI_pquery (QueryDesc *queryDesc, bool fire_triggers, uint64 tcount)
static void	_SPI_error_callback (void *arg)
static void	_SPI_cursor_operation (Portal portal, FetchDirection direction, long count, DestReceiver *dest)
static SPIPlanPtr	_SPI_make_plan_non_temp (SPIPlanPtr plan)
static SPIPlanPtr	_SPI_save_plan (SPIPlanPtr plan)
static int	_SPI_begin_call (bool use_exec)
static int	_SPI_end_call (bool use_exec)
static MemoryContext	_SPI_execmem (void)
static MemoryContext	_SPI_procmem (void)
static bool	_SPI_checktuples (void)
int	SPI_connect (void)
int	SPI_connect_ext (int options)
int	SPI_finish (void)
void	SPI_start_transaction (void)
static void	_SPI_commit (bool chain)
void	SPI_commit (void)
void	SPI_commit_and_chain (void)
static void	_SPI_rollback (bool chain)
void	SPI_rollback (void)
void	SPI_rollback_and_chain (void)
void	AtEOXact_SPI (bool isCommit)
void	AtEOSubXact_SPI (bool isCommit, SubTransactionId mySubid)
bool	SPI_inside_nonatomic_context (void)
int	SPI_execute (const char *src, bool read_only, long tcount)
int	SPI_exec (const char *src, long tcount)
int	SPI_execute_extended (const char *src, const SPIExecuteOptions *options)
int	SPI_execute_plan (SPIPlanPtr plan, Datum *Values, const char *Nulls, bool read_only, long tcount)
int	SPI_execp (SPIPlanPtr plan, Datum *Values, const char *Nulls, long tcount)
int	SPI_execute_plan_extended (SPIPlanPtr plan, const SPIExecuteOptions *options)
int	SPI_execute_plan_with_paramlist (SPIPlanPtr plan, ParamListInfo params, bool read_only, long tcount)
int	SPI_execute_snapshot (SPIPlanPtr plan, Datum *Values, const char *Nulls, Snapshot snapshot, Snapshot crosscheck_snapshot, bool read_only, bool fire_triggers, long tcount)
int	SPI_execute_with_args (const char *src, int nargs, Oid *argtypes, Datum *Values, const char *Nulls, bool read_only, long tcount)
SPIPlanPtr	SPI_prepare (const char *src, int nargs, Oid *argtypes)
SPIPlanPtr	SPI_prepare_cursor (const char *src, int nargs, Oid *argtypes, int cursorOptions)
SPIPlanPtr	SPI_prepare_extended (const char *src, const SPIPrepareOptions *options)
SPIPlanPtr	SPI_prepare_params (const char *src, ParserSetupHook parserSetup, void *parserSetupArg, int cursorOptions)
int	SPI_keepplan (SPIPlanPtr plan)
SPIPlanPtr	SPI_saveplan (SPIPlanPtr plan)
int	SPI_freeplan (SPIPlanPtr plan)
HeapTuple	SPI_copytuple (HeapTuple tuple)
HeapTupleHeader	SPI_returntuple (HeapTuple tuple, TupleDesc tupdesc)
HeapTuple	SPI_modifytuple (Relation rel, HeapTuple tuple, int natts, int *attnum, Datum *Values, const char *Nulls)
int	SPI_fnumber (TupleDesc tupdesc, const char *fname)
char *	SPI_fname (TupleDesc tupdesc, int fnumber)
char *	SPI_getvalue (HeapTuple tuple, TupleDesc tupdesc, int fnumber)
Datum	SPI_getbinval (HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull)
char *	SPI_gettype (TupleDesc tupdesc, int fnumber)
Oid	SPI_gettypeid (TupleDesc tupdesc, int fnumber)
char *	SPI_getrelname (Relation rel)
char *	SPI_getnspname (Relation rel)
void *	SPI_palloc (Size size)
void *	SPI_repalloc (void *pointer, Size size)
void	SPI_pfree (void *pointer)
Datum	SPI_datumTransfer (Datum value, bool typByVal, int typLen)
void	SPI_freetuple (HeapTuple tuple)
void	SPI_freetuptable (SPITupleTable *tuptable)
Portal	SPI_cursor_open (const char *name, SPIPlanPtr plan, Datum *Values, const char *Nulls, bool read_only)
Portal	SPI_cursor_open_with_args (const char *name, const char *src, int nargs, Oid *argtypes, Datum *Values, const char *Nulls, bool read_only, int cursorOptions)
Portal	SPI_cursor_open_with_paramlist (const char *name, SPIPlanPtr plan, ParamListInfo params, bool read_only)
Portal	SPI_cursor_parse_open (const char *name, const char *src, const SPIParseOpenOptions *options)
Portal	SPI_cursor_find (const char *name)
void	SPI_cursor_fetch (Portal portal, bool forward, long count)
void	SPI_cursor_move (Portal portal, bool forward, long count)
void	SPI_scroll_cursor_fetch (Portal portal, FetchDirection direction, long count)
void	SPI_scroll_cursor_move (Portal portal, FetchDirection direction, long count)
void	SPI_cursor_close (Portal portal)
Oid	SPI_getargtypeid (SPIPlanPtr plan, int argIndex)
int	SPI_getargcount (SPIPlanPtr plan)
bool	SPI_is_cursor_plan (SPIPlanPtr plan)
bool	SPI_plan_is_valid (SPIPlanPtr plan)
const char *	SPI_result_code_string (int code)
List *	SPI_plan_get_plan_sources (SPIPlanPtr plan)
CachedPlan *	SPI_plan_get_cached_plan (SPIPlanPtr plan)
void	spi_dest_startup (DestReceiver *self, int operation, TupleDesc typeinfo)
bool	spi_printtup (TupleTableSlot *slot, DestReceiver *self)
static EphemeralNamedRelation	_SPI_find_ENR_by_name (const char *name)
int	SPI_register_relation (EphemeralNamedRelation enr)
int	SPI_unregister_relation (const char *name)
int	SPI_register_trigger_data (TriggerData *tdata)

Variables
uint64	SPI_processed = 0
SPITupleTable *	SPI_tuptable = NULL
int	SPI_result = 0
static _SPI_connection *	_SPI_stack = NULL
static _SPI_connection *	_SPI_current = NULL
static int	_SPI_stack_depth = 0
static int	_SPI_connected = -1

Typedef Documentation

SPICallbackArg

typedef struct SPICallbackArg SPICallbackArg

Function Documentation

_SPI_begin_call()

static int _SPI_begin_call ( bool  use_exec )

static

Definition at line 3053 of file spi.c.

{
    if (_SPI_current == NULL)
        return SPI_ERROR_UNCONNECTED;
 
    if (use_exec)
    {
        /* remember when the Executor operation started */
        _SPI_current->execSubid = GetCurrentSubTransactionId();
        /* switch to the Executor memory context */
        _SPI_execmem();
    }
 
    return 0;
}

References _SPI_current, _SPI_execmem(), _SPI_connection::execSubid, GetCurrentSubTransactionId(), and SPI_ERROR_UNCONNECTED.

Referenced by _SPI_cursor_operation(), SPI_cursor_open_internal(), SPI_cursor_open_with_args(), SPI_cursor_parse_open(), SPI_execute(), SPI_execute_extended(), SPI_execute_plan(), SPI_execute_plan_extended(), SPI_execute_plan_with_paramlist(), SPI_execute_snapshot(), SPI_execute_with_args(), SPI_finish(), SPI_prepare_cursor(), SPI_prepare_extended(), SPI_prepare_params(), SPI_register_relation(), SPI_saveplan(), and SPI_unregister_relation().

_SPI_checktuples()

static bool _SPI_checktuples ( void  )

static

Definition at line 3093 of file spi.c.

{
    uint64      processed = _SPI_current->processed;
    SPITupleTable *tuptable = _SPI_current->tuptable;
    bool        failed = false;
 
    if (tuptable == NULL)       /* spi_dest_startup was not called */
        failed = true;
    else if (processed != tuptable->numvals)
        failed = true;
 
    return failed;
}

References _SPI_current, SPITupleTable::numvals, _SPI_connection::processed, and _SPI_connection::tuptable.

Referenced by _SPI_cursor_operation(), and _SPI_pquery().

_SPI_commit()

static void _SPI_commit ( bool  chain )

static

Definition at line 228 of file spi.c.

{
    MemoryContext oldcontext = CurrentMemoryContext;
    SavedTransactionCharacteristics savetc;
 
    /*
     * Complain if we are in a context that doesn't permit transaction
     * termination.  (Note: here and _SPI_rollback should be the only places
     * that throw ERRCODE_INVALID_TRANSACTION_TERMINATION, so that callers can
     * test for that with security that they know what happened.)
     */
    if (_SPI_current->atomic)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_TERMINATION),
                 errmsg("invalid transaction termination")));
 
    /*
     * This restriction is required by PLs implemented on top of SPI.  They
     * use subtransactions to establish exception blocks that are supposed to
     * be rolled back together if there is an error.  Terminating the
     * top-level transaction in such a block violates that idea.  A future PL
     * implementation might have different ideas about this, in which case
     * this restriction would have to be refined or the check possibly be
     * moved out of SPI into the PLs.  Note however that the code below relies
     * on not being within a subtransaction.
     */
    if (IsSubTransaction())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_TERMINATION),
                 errmsg("cannot commit while a subtransaction is active")));
 
    if (chain)
        SaveTransactionCharacteristics(&savetc);
 
    /* Catch any error occurring during the COMMIT */
    PG_TRY();
    {
        /* Protect current SPI stack entry against deletion */
        _SPI_current->internal_xact = true;
 
        /*
         * Hold any pinned portals that any PLs might be using.  We have to do
         * this before changing transaction state, since this will run
         * user-defined code that might throw an error.
         */
        HoldPinnedPortals();
 
        /* Release snapshots associated with portals */
        ForgetPortalSnapshots();
 
        /* Do the deed */
        CommitTransactionCommand();
 
        /* Immediately start a new transaction */
        StartTransactionCommand();
        if (chain)
            RestoreTransactionCharacteristics(&savetc);
 
        MemoryContextSwitchTo(oldcontext);
 
        _SPI_current->internal_xact = false;
    }
    PG_CATCH();
    {
        ErrorData  *edata;
 
        /* Save error info in caller's context */
        MemoryContextSwitchTo(oldcontext);
        edata = CopyErrorData();
        FlushErrorState();
 
        /*
         * Abort the failed transaction.  If this fails too, we'll just
         * propagate the error out ... there's not that much we can do.
         */
        AbortCurrentTransaction();
 
        /* ... and start a new one */
        StartTransactionCommand();
        if (chain)
            RestoreTransactionCharacteristics(&savetc);
 
        MemoryContextSwitchTo(oldcontext);
 
        _SPI_current->internal_xact = false;
 
        /* Now that we've cleaned up the transaction, re-throw the error */
        ReThrowError(edata);
    }
    PG_END_TRY();
}

References _SPI_current, AbortCurrentTransaction(), _SPI_connection::atomic, CommitTransactionCommand(), CopyErrorData(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, FlushErrorState(), ForgetPortalSnapshots(), HoldPinnedPortals(), _SPI_connection::internal_xact, IsSubTransaction(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_TRY, RestoreTransactionCharacteristics(), ReThrowError(), SaveTransactionCharacteristics(), and StartTransactionCommand().

Referenced by SPI_commit(), and SPI_commit_and_chain().

_SPI_convert_params()

static ParamListInfo _SPI_convert_params ( int  nargs, Oid *  argtypes, Datum *  Values, const char *  Nulls  )

static

Definition at line 2828 of file spi.c.

{
    ParamListInfo paramLI;
 
    if (nargs > 0)
    {
        paramLI = makeParamList(nargs);
 
        for (int i = 0; i < nargs; i++)
        {
            ParamExternData *prm = &paramLI->params[i];
 
            prm->value = Values[i];
            prm->isnull = (Nulls && Nulls[i] == 'n');
            prm->pflags = PARAM_FLAG_CONST;
            prm->ptype = argtypes[i];
        }
    }
    else
        paramLI = NULL;
    return paramLI;
}

References i, ParamExternData::isnull, makeParamList(), Nulls, PARAM_FLAG_CONST, ParamListInfoData::params, ParamExternData::pflags, ParamExternData::ptype, and ParamExternData::value.

Referenced by SPI_cursor_open(), SPI_cursor_open_with_args(), SPI_execute_plan(), SPI_execute_snapshot(), and SPI_execute_with_args().

_SPI_cursor_operation()

static void _SPI_cursor_operation ( Portal  portal, FetchDirection  direction, long  count, DestReceiver *  dest  )

static

Definition at line 2983 of file spi.c.

{
    uint64      nfetched;
 
    /* Check that the portal is valid */
    if (!PortalIsValid(portal))
        elog(ERROR, "invalid portal in SPI cursor operation");
 
    /* Push the SPI stack */
    if (_SPI_begin_call(true) < 0)
        elog(ERROR, "SPI cursor operation called while not connected");
 
    /* Reset the SPI result (note we deliberately don't touch lastoid) */
    SPI_processed = 0;
    SPI_tuptable = NULL;
    _SPI_current->processed = 0;
    _SPI_current->tuptable = NULL;
 
    /* Run the cursor */
    nfetched = PortalRunFetch(portal,
                              direction,
                              count,
                              dest);
 
    /*
     * Think not to combine this store with the preceding function call. If
     * the portal contains calls to functions that use SPI, then _SPI_stack is
     * likely to move around while the portal runs.  When control returns,
     * _SPI_current will point to the correct stack entry... but the pointer
     * may be different than it was beforehand. So we must be sure to re-fetch
     * the pointer after the function call completes.
     */
    _SPI_current->processed = nfetched;
 
    if (dest->mydest == DestSPI && _SPI_checktuples())
        elog(ERROR, "consistency check on SPI tuple count failed");
 
    /* Put the result into place for access by caller */
    SPI_processed = _SPI_current->processed;
    SPI_tuptable = _SPI_current->tuptable;
 
    /* tuptable now is caller's responsibility, not SPI's */
    _SPI_current->tuptable = NULL;
 
    /* Pop the SPI stack */
    _SPI_end_call(true);
}

References _SPI_begin_call(), _SPI_checktuples(), _SPI_current, _SPI_end_call(), generate_unaccent_rules::dest, DestSPI, elog(), ERROR, PortalIsValid, PortalRunFetch(), _SPI_connection::processed, SPI_processed, SPI_tuptable, and _SPI_connection::tuptable.

Referenced by SPI_cursor_fetch(), SPI_cursor_move(), SPI_scroll_cursor_fetch(), and SPI_scroll_cursor_move().

_SPI_end_call()

static int _SPI_end_call ( bool  use_exec )

static

Definition at line 3077 of file spi.c.

{
    if (use_exec)
    {
        /* switch to the procedure memory context */
        _SPI_procmem();
        /* mark Executor context no longer in use */
        _SPI_current->execSubid = InvalidSubTransactionId;
        /* and free Executor memory */
        MemoryContextResetAndDeleteChildren(_SPI_current->execCxt);
    }
 
    return 0;
}

References _SPI_current, _SPI_procmem(), _SPI_connection::execCxt, _SPI_connection::execSubid, InvalidSubTransactionId, and MemoryContextResetAndDeleteChildren.

Referenced by _SPI_cursor_operation(), SPI_cursor_open_internal(), SPI_cursor_open_with_args(), SPI_cursor_parse_open(), SPI_execute(), SPI_execute_extended(), SPI_execute_plan(), SPI_execute_plan_extended(), SPI_execute_plan_with_paramlist(), SPI_execute_snapshot(), SPI_execute_with_args(), SPI_prepare_cursor(), SPI_prepare_extended(), SPI_prepare_params(), SPI_register_relation(), SPI_saveplan(), and SPI_unregister_relation().

_SPI_error_callback()

static void _SPI_error_callback ( void *  arg )

static

Definition at line 2937 of file spi.c.

{
    SPICallbackArg *carg = (SPICallbackArg *) arg;
    const char *query = carg->query;
    int         syntaxerrposition;
 
    if (query == NULL)          /* in case arg wasn't set yet */
        return;
 
    /*
     * If there is a syntax error position, convert to internal syntax error;
     * otherwise treat the query as an item of context stack
     */
    syntaxerrposition = geterrposition();
    if (syntaxerrposition > 0)
    {
        errposition(0);
        internalerrposition(syntaxerrposition);
        internalerrquery(query);
    }
    else
    {
        /* Use the parse mode to decide how to describe the query */
        switch (carg->mode)
        {
            case RAW_PARSE_PLPGSQL_EXPR:
                errcontext("SQL expression \"%s\"", query);
                break;
            case RAW_PARSE_PLPGSQL_ASSIGN1:
            case RAW_PARSE_PLPGSQL_ASSIGN2:
            case RAW_PARSE_PLPGSQL_ASSIGN3:
                errcontext("PL/pgSQL assignment \"%s\"", query);
                break;
            default:
                errcontext("SQL statement \"%s\"", query);
                break;
        }
    }
}

References arg, errcontext, errposition(), geterrposition(), internalerrposition(), internalerrquery(), SPICallbackArg::mode, SPICallbackArg::query, RAW_PARSE_PLPGSQL_ASSIGN1, RAW_PARSE_PLPGSQL_ASSIGN2, RAW_PARSE_PLPGSQL_ASSIGN3, and RAW_PARSE_PLPGSQL_EXPR.

Referenced by _SPI_execute_plan(), _SPI_prepare_oneshot_plan(), _SPI_prepare_plan(), SPI_cursor_open_internal(), and SPI_plan_get_cached_plan().

_SPI_execmem()

static MemoryContext _SPI_execmem ( void  )

static

Definition at line 3034 of file spi.c.

{
    return MemoryContextSwitchTo(_SPI_current->execCxt);
}

References _SPI_current, _SPI_connection::execCxt, and MemoryContextSwitchTo().

Referenced by _SPI_begin_call().

_SPI_execute_plan()

static int _SPI_execute_plan ( SPIPlanPtr  plan, const SPIExecuteOptions *  options, Snapshot  snapshot, Snapshot  crosscheck_snapshot, bool  fire_triggers  )

static

Definition at line 2393 of file spi.c.

{
    int         my_res = 0;
    uint64      my_processed = 0;
    SPITupleTable *my_tuptable = NULL;
    int         res = 0;
    bool        pushed_active_snap = false;
    ResourceOwner plan_owner = options->owner;
    SPICallbackArg spicallbackarg;
    ErrorContextCallback spierrcontext;
    CachedPlan *cplan = NULL;
    ListCell   *lc1;
 
    /*
     * Setup error traceback support for ereport()
     */
    spicallbackarg.query = NULL;    /* we'll fill this below */
    spicallbackarg.mode = plan->parse_mode;
    spierrcontext.callback = _SPI_error_callback;
    spierrcontext.arg = &spicallbackarg;
    spierrcontext.previous = error_context_stack;
    error_context_stack = &spierrcontext;
 
    /*
     * We support four distinct snapshot management behaviors:
     *
     * snapshot != InvalidSnapshot, read_only = true: use exactly the given
     * snapshot.
     *
     * snapshot != InvalidSnapshot, read_only = false: use the given snapshot,
     * modified by advancing its command ID before each querytree.
     *
     * snapshot == InvalidSnapshot, read_only = true: use the entry-time
     * ActiveSnapshot, if any (if there isn't one, we run with no snapshot).
     *
     * snapshot == InvalidSnapshot, read_only = false: take a full new
     * snapshot for each user command, and advance its command ID before each
     * querytree within the command.
     *
     * In the first two cases, we can just push the snap onto the stack once
     * for the whole plan list.
     *
     * Note that snapshot != InvalidSnapshot implies an atomic execution
     * context.
     */
    if (snapshot != InvalidSnapshot)
    {
        Assert(!options->allow_nonatomic);
        if (options->read_only)
        {
            PushActiveSnapshot(snapshot);
            pushed_active_snap = true;
        }
        else
        {
            /* Make sure we have a private copy of the snapshot to modify */
            PushCopiedSnapshot(snapshot);
            pushed_active_snap = true;
        }
    }
 
    /*
     * Ensure that we have a resource owner if plan is saved, and not if it
     * isn't.
     */
    if (!plan->saved)
        plan_owner = NULL;
    else if (plan_owner == NULL)
        plan_owner = CurrentResourceOwner;
 
    /*
     * We interpret must_return_tuples as "there must be at least one query,
     * and all of them must return tuples".  This is a bit laxer than
     * SPI_is_cursor_plan's check, but there seems no reason to enforce that
     * there be only one query.
     */
    if (options->must_return_tuples && plan->plancache_list == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("empty query does not return tuples")));
 
    foreach(lc1, plan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc1);
        List       *stmt_list;
        ListCell   *lc2;
 
        spicallbackarg.query = plansource->query_string;
 
        /*
         * If this is a one-shot plan, we still need to do parse analysis.
         */
        if (plan->oneshot)
        {
            RawStmt    *parsetree = plansource->raw_parse_tree;
            const char *src = plansource->query_string;
            List       *querytree_list;
 
            /*
             * Parameter datatypes are driven by parserSetup hook if provided,
             * otherwise we use the fixed parameter list.
             */
            if (parsetree == NULL)
                querytree_list = NIL;
            else if (plan->parserSetup != NULL)
            {
                Assert(plan->nargs == 0);
                querytree_list = pg_analyze_and_rewrite_withcb(parsetree,
                                                               src,
                                                               plan->parserSetup,
                                                               plan->parserSetupArg,
                                                               _SPI_current->queryEnv);
            }
            else
            {
                querytree_list = pg_analyze_and_rewrite_fixedparams(parsetree,
                                                                    src,
                                                                    plan->argtypes,
                                                                    plan->nargs,
                                                                    _SPI_current->queryEnv);
            }
 
            /* Finish filling in the CachedPlanSource */
            CompleteCachedPlan(plansource,
                               querytree_list,
                               NULL,
                               plan->argtypes,
                               plan->nargs,
                               plan->parserSetup,
                               plan->parserSetupArg,
                               plan->cursor_options,
                               false);  /* not fixed result */
        }
 
        /*
         * If asked to, complain when query does not return tuples.
         * (Replanning can't change this, so we can check it before that.
         * However, we can't check it till after parse analysis, so in the
         * case of a one-shot plan this is the earliest we could check.)
         */
        if (options->must_return_tuples && !plansource->resultDesc)
        {
            /* try to give a good error message */
            const char *cmdtag;
 
            /* A SELECT without resultDesc must be SELECT INTO */
            if (plansource->commandTag == CMDTAG_SELECT)
                cmdtag = "SELECT INTO";
            else
                cmdtag = GetCommandTagName(plansource->commandTag);
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
            /* translator: %s is name of a SQL command, eg INSERT */
                     errmsg("%s query does not return tuples", cmdtag)));
        }
 
        /*
         * Replan if needed, and increment plan refcount.  If it's a saved
         * plan, the refcount must be backed by the plan_owner.
         */
        cplan = GetCachedPlan(plansource, options->params,
                              plan_owner, _SPI_current->queryEnv);
 
        stmt_list = cplan->stmt_list;
 
        /*
         * If we weren't given a specific snapshot to use, and the statement
         * list requires a snapshot, set that up.
         */
        if (snapshot == InvalidSnapshot &&
            (list_length(stmt_list) > 1 ||
             (list_length(stmt_list) == 1 &&
              PlannedStmtRequiresSnapshot(linitial_node(PlannedStmt,
                                                        stmt_list)))))
        {
            /*
             * First, ensure there's a Portal-level snapshot.  This back-fills
             * the snapshot stack in case the previous operation was a COMMIT
             * or ROLLBACK inside a procedure or DO block.  (We can't put back
             * the Portal snapshot any sooner, or we'd break cases like doing
             * SET or LOCK just after COMMIT.)  It's enough to check once per
             * statement list, since COMMIT/ROLLBACK/CALL/DO can't appear
             * within a multi-statement list.
             */
            EnsurePortalSnapshotExists();
 
            /*
             * In the default non-read-only case, get a new per-statement-list
             * snapshot, replacing any that we pushed in a previous cycle.
             * Skip it when doing non-atomic execution, though (we rely
             * entirely on the Portal snapshot in that case).
             */
            if (!options->read_only && !options->allow_nonatomic)
            {
                if (pushed_active_snap)
                    PopActiveSnapshot();
                PushActiveSnapshot(GetTransactionSnapshot());
                pushed_active_snap = true;
            }
        }
 
        foreach(lc2, stmt_list)
        {
            PlannedStmt *stmt = lfirst_node(PlannedStmt, lc2);
            bool        canSetTag = stmt->canSetTag;
            DestReceiver *dest;
 
            /*
             * Reset output state.  (Note that if a non-SPI receiver is used,
             * _SPI_current->processed will stay zero, and that's what we'll
             * report to the caller.  It's the receiver's job to count tuples
             * in that case.)
             */
            _SPI_current->processed = 0;
            _SPI_current->tuptable = NULL;
 
            /* Check for unsupported cases. */
            if (stmt->utilityStmt)
            {
                if (IsA(stmt->utilityStmt, CopyStmt))
                {
                    CopyStmt   *cstmt = (CopyStmt *) stmt->utilityStmt;
 
                    if (cstmt->filename == NULL)
                    {
                        my_res = SPI_ERROR_COPY;
                        goto fail;
                    }
                }
                else if (IsA(stmt->utilityStmt, TransactionStmt))
                {
                    my_res = SPI_ERROR_TRANSACTION;
                    goto fail;
                }
            }
 
            if (options->read_only && !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))));
 
            /*
             * If not read-only mode, advance the command counter before each
             * command and update the snapshot.  (But skip it if the snapshot
             * isn't under our control.)
             */
            if (!options->read_only && pushed_active_snap)
            {
                CommandCounterIncrement();
                UpdateActiveSnapshotCommandId();
            }
 
            /*
             * Select appropriate tuple receiver.  Output from non-canSetTag
             * subqueries always goes to the bit bucket.
             */
            if (!canSetTag)
                dest = CreateDestReceiver(DestNone);
            else if (options->dest)
                dest = options->dest;
            else
                dest = CreateDestReceiver(DestSPI);
 
            if (stmt->utilityStmt == NULL)
            {
                QueryDesc  *qdesc;
                Snapshot    snap;
 
                if (ActiveSnapshotSet())
                    snap = GetActiveSnapshot();
                else
                    snap = InvalidSnapshot;
 
                qdesc = CreateQueryDesc(stmt,
                                        plansource->query_string,
                                        snap, crosscheck_snapshot,
                                        dest,
                                        options->params,
                                        _SPI_current->queryEnv,
                                        0);
                res = _SPI_pquery(qdesc, fire_triggers,
                                  canSetTag ? options->tcount : 0);
                FreeQueryDesc(qdesc);
            }
            else
            {
                ProcessUtilityContext context;
                QueryCompletion qc;
 
                /*
                 * If the SPI context is atomic, or we were not told to allow
                 * nonatomic operations, tell ProcessUtility this is an atomic
                 * execution context.
                 */
                if (_SPI_current->atomic || !options->allow_nonatomic)
                    context = PROCESS_UTILITY_QUERY;
                else
                    context = PROCESS_UTILITY_QUERY_NONATOMIC;
 
                InitializeQueryCompletion(&qc);
                ProcessUtility(stmt,
                               plansource->query_string,
                               true,    /* protect plancache's node tree */
                               context,
                               options->params,
                               _SPI_current->queryEnv,
                               dest,
                               &qc);
 
                /* Update "processed" if stmt returned tuples */
                if (_SPI_current->tuptable)
                    _SPI_current->processed = _SPI_current->tuptable->numvals;
 
                res = SPI_OK_UTILITY;
 
                /*
                 * Some utility statements return a row count, even though the
                 * tuples are not returned to the caller.
                 */
                if (IsA(stmt->utilityStmt, CreateTableAsStmt))
                {
                    CreateTableAsStmt *ctastmt = (CreateTableAsStmt *) stmt->utilityStmt;
 
                    if (qc.commandTag == CMDTAG_SELECT)
                        _SPI_current->processed = qc.nprocessed;
                    else
                    {
                        /*
                         * Must be an IF NOT EXISTS that did nothing, or a
                         * CREATE ... WITH NO DATA.
                         */
                        Assert(ctastmt->if_not_exists ||
                               ctastmt->into->skipData);
                        _SPI_current->processed = 0;
                    }
 
                    /*
                     * For historical reasons, if CREATE TABLE AS was spelled
                     * as SELECT INTO, return a special return code.
                     */
                    if (ctastmt->is_select_into)
                        res = SPI_OK_SELINTO;
                }
                else if (IsA(stmt->utilityStmt, CopyStmt))
                {
                    Assert(qc.commandTag == CMDTAG_COPY);
                    _SPI_current->processed = qc.nprocessed;
                }
            }
 
            /*
             * The last canSetTag query sets the status values returned to the
             * caller.  Be careful to free any tuptables not returned, to
             * avoid intra-transaction memory leak.
             */
            if (canSetTag)
            {
                my_processed = _SPI_current->processed;
                SPI_freetuptable(my_tuptable);
                my_tuptable = _SPI_current->tuptable;
                my_res = res;
            }
            else
            {
                SPI_freetuptable(_SPI_current->tuptable);
                _SPI_current->tuptable = NULL;
            }
 
            /*
             * We don't issue a destroy call to the receiver.  The SPI and
             * None receivers would ignore it anyway, while if the caller
             * supplied a receiver, it's not our job to destroy it.
             */
 
            if (res < 0)
            {
                my_res = res;
                goto fail;
            }
        }
 
        /* Done with this plan, so release refcount */
        ReleaseCachedPlan(cplan, plan_owner);
        cplan = NULL;
 
        /*
         * If not read-only mode, advance the command counter after the last
         * command.  This ensures that its effects are visible, in case it was
         * DDL that would affect the next CachedPlanSource.
         */
        if (!options->read_only)
            CommandCounterIncrement();
    }
 
fail:
 
    /* Pop the snapshot off the stack if we pushed one */
    if (pushed_active_snap)
        PopActiveSnapshot();
 
    /* We no longer need the cached plan refcount, if any */
    if (cplan)
        ReleaseCachedPlan(cplan, plan_owner);
 
    /*
     * Pop the error context stack
     */
    error_context_stack = spierrcontext.previous;
 
    /* Save results for caller */
    SPI_processed = my_processed;
    SPI_tuptable = my_tuptable;
 
    /* tuptable now is caller's responsibility, not SPI's */
    _SPI_current->tuptable = NULL;
 
    /*
     * If none of the queries had canSetTag, return SPI_OK_REWRITTEN. Prior to
     * 8.4, we used return the last query's result code, but not its auxiliary
     * results, but that's confusing.
     */
    if (my_res == 0)
        my_res = SPI_OK_REWRITTEN;
 
    return my_res;
}

References _SPI_current, _SPI_error_callback(), _SPI_pquery(), ActiveSnapshotSet(), ErrorContextCallback::arg, Assert(), _SPI_connection::atomic, ErrorContextCallback::callback, CommandCounterIncrement(), CommandIsReadOnly(), QueryCompletion::commandTag, CachedPlanSource::commandTag, CompleteCachedPlan(), CreateCommandName(), CreateDestReceiver(), CreateQueryDesc(), CurrentResourceOwner, generate_unaccent_rules::dest, DestNone, DestSPI, EnsurePortalSnapshotExists(), ereport, errcode(), errmsg(), ERROR, error_context_stack, CopyStmt::filename, FreeQueryDesc(), GetActiveSnapshot(), GetCachedPlan(), GetCommandTagName(), GetTransactionSnapshot(), if(), CreateTableAsStmt::if_not_exists, InitializeQueryCompletion(), CreateTableAsStmt::into, InvalidSnapshot, CreateTableAsStmt::is_select_into, IsA, lfirst, lfirst_node, linitial_node, list_length(), SPICallbackArg::mode, NIL, QueryCompletion::nprocessed, SPITupleTable::numvals, pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_withcb(), plan, PlannedStmtRequiresSnapshot(), PopActiveSnapshot(), ErrorContextCallback::previous, PROCESS_UTILITY_QUERY, PROCESS_UTILITY_QUERY_NONATOMIC, _SPI_connection::processed, ProcessUtility(), PushActiveSnapshot(), PushCopiedSnapshot(), SPICallbackArg::query, CachedPlanSource::query_string, _SPI_connection::queryEnv, CachedPlanSource::raw_parse_tree, ReleaseCachedPlan(), res, CachedPlanSource::resultDesc, IntoClause::skipData, SPI_ERROR_COPY, SPI_ERROR_TRANSACTION, SPI_freetuptable(), SPI_OK_REWRITTEN, SPI_OK_SELINTO, SPI_OK_UTILITY, SPI_processed, SPI_tuptable, stmt, CachedPlan::stmt_list, _SPI_connection::tuptable, and UpdateActiveSnapshotCommandId().

Referenced by SPI_execute(), SPI_execute_extended(), SPI_execute_plan(), SPI_execute_plan_extended(), SPI_execute_plan_with_paramlist(), SPI_execute_snapshot(), and SPI_execute_with_args().

_SPI_find_ENR_by_name()

static EphemeralNamedRelation _SPI_find_ENR_by_name ( const char *  name )

static

Definition at line 3256 of file spi.c.

{
    /* internal static function; any error is bug in SPI itself */
    Assert(name != NULL);
 
    /* fast exit if no tuplestores have been added */
    if (_SPI_current->queryEnv == NULL)
        return NULL;
 
    return get_ENR(_SPI_current->queryEnv, name);
}

References _SPI_current, Assert(), get_ENR(), name, and _SPI_connection::queryEnv.

Referenced by SPI_register_relation(), and SPI_unregister_relation().

_SPI_make_plan_non_temp()

static SPIPlanPtr _SPI_make_plan_non_temp ( SPIPlanPtr  plan )

static

Definition at line 3117 of file spi.c.

{
    SPIPlanPtr  newplan;
    MemoryContext parentcxt = _SPI_current->procCxt;
    MemoryContext plancxt;
    MemoryContext oldcxt;
    ListCell   *lc;
 
    /* Assert the input is a temporary SPIPlan */
    Assert(plan->magic == _SPI_PLAN_MAGIC);
    Assert(plan->plancxt == NULL);
    /* One-shot plans can't be saved */
    Assert(!plan->oneshot);
 
    /*
     * Create a memory context for the plan, underneath the procedure context.
     * We don't expect the plan to be very large.
     */
    plancxt = AllocSetContextCreate(parentcxt,
                                    "SPI Plan",
                                    ALLOCSET_SMALL_SIZES);
    oldcxt = MemoryContextSwitchTo(plancxt);
 
    /* Copy the _SPI_plan struct and subsidiary data into the new context */
    newplan = (SPIPlanPtr) palloc0(sizeof(_SPI_plan));
    newplan->magic = _SPI_PLAN_MAGIC;
    newplan->plancxt = plancxt;
    newplan->parse_mode = plan->parse_mode;
    newplan->cursor_options = plan->cursor_options;
    newplan->nargs = plan->nargs;
    if (plan->nargs > 0)
    {
        newplan->argtypes = (Oid *) palloc(plan->nargs * sizeof(Oid));
        memcpy(newplan->argtypes, plan->argtypes, plan->nargs * sizeof(Oid));
    }
    else
        newplan->argtypes = NULL;
    newplan->parserSetup = plan->parserSetup;
    newplan->parserSetupArg = plan->parserSetupArg;
 
    /*
     * Reparent all the CachedPlanSources into the procedure context.  In
     * theory this could fail partway through due to the pallocs, but we don't
     * care too much since both the procedure context and the executor context
     * would go away on error.
     */
    foreach(lc, plan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
 
        CachedPlanSetParentContext(plansource, parentcxt);
 
        /* Build new list, with list cells in plancxt */
        newplan->plancache_list = lappend(newplan->plancache_list, plansource);
    }
 
    MemoryContextSwitchTo(oldcxt);
 
    /* For safety, unlink the CachedPlanSources from the temporary plan */
    plan->plancache_list = NIL;
 
    return newplan;
}

References _SPI_current, _SPI_PLAN_MAGIC, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, _SPI_plan::argtypes, Assert(), CachedPlanSetParentContext(), _SPI_plan::cursor_options, lappend(), lfirst, _SPI_plan::magic, MemoryContextSwitchTo(), _SPI_plan::nargs, NIL, palloc(), palloc0(), _SPI_plan::parse_mode, _SPI_plan::parserSetup, _SPI_plan::parserSetupArg, plan, _SPI_plan::plancache_list, _SPI_plan::plancxt, and _SPI_connection::procCxt.

Referenced by SPI_prepare_cursor(), SPI_prepare_extended(), and SPI_prepare_params().

_SPI_pquery()

static int _SPI_pquery ( QueryDesc *  queryDesc, bool  fire_triggers, uint64  tcount  )

static

Definition at line 2853 of file spi.c.

{
    int         operation = queryDesc->operation;
    int         eflags;
    int         res;
 
    switch (operation)
    {
        case CMD_SELECT:
            if (queryDesc->dest->mydest == DestNone)
            {
                /* Don't return SPI_OK_SELECT if we're discarding result */
                res = SPI_OK_UTILITY;
            }
            else
                res = SPI_OK_SELECT;
            break;
        case CMD_INSERT:
            if (queryDesc->plannedstmt->hasReturning)
                res = SPI_OK_INSERT_RETURNING;
            else
                res = SPI_OK_INSERT;
            break;
        case CMD_DELETE:
            if (queryDesc->plannedstmt->hasReturning)
                res = SPI_OK_DELETE_RETURNING;
            else
                res = SPI_OK_DELETE;
            break;
        case CMD_UPDATE:
            if (queryDesc->plannedstmt->hasReturning)
                res = SPI_OK_UPDATE_RETURNING;
            else
                res = SPI_OK_UPDATE;
            break;
        case CMD_MERGE:
            res = SPI_OK_MERGE;
            break;
        default:
            return SPI_ERROR_OPUNKNOWN;
    }
 
#ifdef SPI_EXECUTOR_STATS
    if (ShowExecutorStats)
        ResetUsage();
#endif
 
    /* Select execution options */
    if (fire_triggers)
        eflags = 0;             /* default run-to-completion flags */
    else
        eflags = EXEC_FLAG_SKIP_TRIGGERS;
 
    ExecutorStart(queryDesc, eflags);
 
    ExecutorRun(queryDesc, ForwardScanDirection, tcount, true);
 
    _SPI_current->processed = queryDesc->estate->es_processed;
 
    if ((res == SPI_OK_SELECT || queryDesc->plannedstmt->hasReturning) &&
        queryDesc->dest->mydest == DestSPI)
    {
        if (_SPI_checktuples())
            elog(ERROR, "consistency check on SPI tuple count failed");
    }
 
    ExecutorFinish(queryDesc);
    ExecutorEnd(queryDesc);
    /* FreeQueryDesc is done by the caller */
 
#ifdef SPI_EXECUTOR_STATS
    if (ShowExecutorStats)
        ShowUsage("SPI EXECUTOR STATS");
#endif
 
    return res;
}

References _SPI_checktuples(), _SPI_current, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, QueryDesc::dest, DestNone, DestSPI, elog(), ERROR, EState::es_processed, QueryDesc::estate, EXEC_FLAG_SKIP_TRIGGERS, ExecutorEnd(), ExecutorFinish(), ExecutorRun(), ExecutorStart(), ForwardScanDirection, PlannedStmt::hasReturning, _DestReceiver::mydest, QueryDesc::operation, QueryDesc::plannedstmt, _SPI_connection::processed, res, ResetUsage(), ShowUsage(), SPI_ERROR_OPUNKNOWN, SPI_OK_DELETE, SPI_OK_DELETE_RETURNING, SPI_OK_INSERT, SPI_OK_INSERT_RETURNING, SPI_OK_MERGE, SPI_OK_SELECT, SPI_OK_UPDATE, SPI_OK_UPDATE_RETURNING, and SPI_OK_UTILITY.

Referenced by _SPI_execute_plan().

_SPI_prepare_oneshot_plan()

static void _SPI_prepare_oneshot_plan ( const char *  src, SPIPlanPtr  plan  )

static

Definition at line 2323 of file spi.c.

{
    List       *raw_parsetree_list;
    List       *plancache_list;
    ListCell   *list_item;
    SPICallbackArg spicallbackarg;
    ErrorContextCallback spierrcontext;
 
    /*
     * Setup error traceback support for ereport()
     */
    spicallbackarg.query = src;
    spicallbackarg.mode = plan->parse_mode;
    spierrcontext.callback = _SPI_error_callback;
    spierrcontext.arg = &spicallbackarg;
    spierrcontext.previous = error_context_stack;
    error_context_stack = &spierrcontext;
 
    /*
     * Parse the request string into a list of raw parse trees.
     */
    raw_parsetree_list = raw_parser(src, plan->parse_mode);
 
    /*
     * Construct plancache entries, but don't do parse analysis yet.
     */
    plancache_list = NIL;
 
    foreach(list_item, raw_parsetree_list)
    {
        RawStmt    *parsetree = lfirst_node(RawStmt, list_item);
        CachedPlanSource *plansource;
 
        plansource = CreateOneShotCachedPlan(parsetree,
                                             src,
                                             CreateCommandTag(parsetree->stmt));
 
        plancache_list = lappend(plancache_list, plansource);
    }
 
    plan->plancache_list = plancache_list;
    plan->oneshot = true;
 
    /*
     * Pop the error context stack
     */
    error_context_stack = spierrcontext.previous;
}

References _SPI_error_callback(), ErrorContextCallback::arg, ErrorContextCallback::callback, CreateCommandTag(), CreateOneShotCachedPlan(), error_context_stack, lappend(), lfirst_node, SPICallbackArg::mode, NIL, plan, ErrorContextCallback::previous, SPICallbackArg::query, raw_parser(), and RawStmt::stmt.

Referenced by SPI_execute(), SPI_execute_extended(), and SPI_execute_with_args().

_SPI_prepare_plan()

static void _SPI_prepare_plan ( const char *  src, SPIPlanPtr  plan  )

static

Definition at line 2215 of file spi.c.

{
    List       *raw_parsetree_list;
    List       *plancache_list;
    ListCell   *list_item;
    SPICallbackArg spicallbackarg;
    ErrorContextCallback spierrcontext;
 
    /*
     * Setup error traceback support for ereport()
     */
    spicallbackarg.query = src;
    spicallbackarg.mode = plan->parse_mode;
    spierrcontext.callback = _SPI_error_callback;
    spierrcontext.arg = &spicallbackarg;
    spierrcontext.previous = error_context_stack;
    error_context_stack = &spierrcontext;
 
    /*
     * Parse the request string into a list of raw parse trees.
     */
    raw_parsetree_list = raw_parser(src, plan->parse_mode);
 
    /*
     * Do parse analysis and rule rewrite for each raw parsetree, storing the
     * results into unsaved plancache entries.
     */
    plancache_list = NIL;
 
    foreach(list_item, raw_parsetree_list)
    {
        RawStmt    *parsetree = lfirst_node(RawStmt, list_item);
        List       *stmt_list;
        CachedPlanSource *plansource;
 
        /*
         * Create the CachedPlanSource before we do parse analysis, since it
         * needs to see the unmodified raw parse tree.
         */
        plansource = CreateCachedPlan(parsetree,
                                      src,
                                      CreateCommandTag(parsetree->stmt));
 
        /*
         * Parameter datatypes are driven by parserSetup hook if provided,
         * otherwise we use the fixed parameter list.
         */
        if (plan->parserSetup != NULL)
        {
            Assert(plan->nargs == 0);
            stmt_list = pg_analyze_and_rewrite_withcb(parsetree,
                                                      src,
                                                      plan->parserSetup,
                                                      plan->parserSetupArg,
                                                      _SPI_current->queryEnv);
        }
        else
        {
            stmt_list = pg_analyze_and_rewrite_fixedparams(parsetree,
                                                           src,
                                                           plan->argtypes,
                                                           plan->nargs,
                                                           _SPI_current->queryEnv);
        }
 
        /* Finish filling in the CachedPlanSource */
        CompleteCachedPlan(plansource,
                           stmt_list,
                           NULL,
                           plan->argtypes,
                           plan->nargs,
                           plan->parserSetup,
                           plan->parserSetupArg,
                           plan->cursor_options,
                           false);  /* not fixed result */
 
        plancache_list = lappend(plancache_list, plansource);
    }
 
    plan->plancache_list = plancache_list;
    plan->oneshot = false;
 
    /*
     * Pop the error context stack
     */
    error_context_stack = spierrcontext.previous;
}

References _SPI_current, _SPI_error_callback(), ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, CompleteCachedPlan(), CreateCachedPlan(), CreateCommandTag(), error_context_stack, lappend(), lfirst_node, SPICallbackArg::mode, NIL, pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_withcb(), plan, ErrorContextCallback::previous, SPICallbackArg::query, _SPI_connection::queryEnv, raw_parser(), and RawStmt::stmt.

Referenced by SPI_cursor_open_with_args(), SPI_cursor_parse_open(), SPI_prepare_cursor(), SPI_prepare_extended(), and SPI_prepare_params().

_SPI_procmem()

static MemoryContext _SPI_procmem ( void  )

static

Definition at line 3040 of file spi.c.

{
    return MemoryContextSwitchTo(_SPI_current->procCxt);
}

References _SPI_current, MemoryContextSwitchTo(), and _SPI_connection::procCxt.

Referenced by _SPI_end_call(), and spi_dest_startup().

_SPI_rollback()

static void _SPI_rollback ( bool  chain )

static

Definition at line 333 of file spi.c.

{
    MemoryContext oldcontext = CurrentMemoryContext;
    SavedTransactionCharacteristics savetc;
 
    /* see under SPI_commit() */
    if (_SPI_current->atomic)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_TERMINATION),
                 errmsg("invalid transaction termination")));
 
    /* see under SPI_commit() */
    if (IsSubTransaction())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_TERMINATION),
                 errmsg("cannot roll back while a subtransaction is active")));
 
    if (chain)
        SaveTransactionCharacteristics(&savetc);
 
    /* Catch any error occurring during the ROLLBACK */
    PG_TRY();
    {
        /* Protect current SPI stack entry against deletion */
        _SPI_current->internal_xact = true;
 
        /*
         * Hold any pinned portals that any PLs might be using.  We have to do
         * this before changing transaction state, since this will run
         * user-defined code that might throw an error, and in any case
         * couldn't be run in an already-aborted transaction.
         */
        HoldPinnedPortals();
 
        /* Release snapshots associated with portals */
        ForgetPortalSnapshots();
 
        /* Do the deed */
        AbortCurrentTransaction();
 
        /* Immediately start a new transaction */
        StartTransactionCommand();
        if (chain)
            RestoreTransactionCharacteristics(&savetc);
 
        MemoryContextSwitchTo(oldcontext);
 
        _SPI_current->internal_xact = false;
    }
    PG_CATCH();
    {
        ErrorData  *edata;
 
        /* Save error info in caller's context */
        MemoryContextSwitchTo(oldcontext);
        edata = CopyErrorData();
        FlushErrorState();
 
        /*
         * Try again to abort the failed transaction.  If this fails too,
         * we'll just propagate the error out ... there's not that much we can
         * do.
         */
        AbortCurrentTransaction();
 
        /* ... and start a new one */
        StartTransactionCommand();
        if (chain)
            RestoreTransactionCharacteristics(&savetc);
 
        MemoryContextSwitchTo(oldcontext);
 
        _SPI_current->internal_xact = false;
 
        /* Now that we've cleaned up the transaction, re-throw the error */
        ReThrowError(edata);
    }
    PG_END_TRY();
}

References _SPI_current, AbortCurrentTransaction(), _SPI_connection::atomic, CopyErrorData(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, FlushErrorState(), ForgetPortalSnapshots(), HoldPinnedPortals(), _SPI_connection::internal_xact, IsSubTransaction(), MemoryContextSwitchTo(), PG_CATCH, PG_END_TRY, PG_TRY, RestoreTransactionCharacteristics(), ReThrowError(), SaveTransactionCharacteristics(), and StartTransactionCommand().

Referenced by SPI_rollback(), and SPI_rollback_and_chain().

_SPI_save_plan()

static SPIPlanPtr _SPI_save_plan ( SPIPlanPtr  plan )

static

Definition at line 3185 of file spi.c.

{
    SPIPlanPtr  newplan;
    MemoryContext plancxt;
    MemoryContext oldcxt;
    ListCell   *lc;
 
    /* One-shot plans can't be saved */
    Assert(!plan->oneshot);
 
    /*
     * Create a memory context for the plan.  We don't expect the plan to be
     * very large, so use smaller-than-default alloc parameters.  It's a
     * transient context until we finish copying everything.
     */
    plancxt = AllocSetContextCreate(CurrentMemoryContext,
                                    "SPI Plan",
                                    ALLOCSET_SMALL_SIZES);
    oldcxt = MemoryContextSwitchTo(plancxt);
 
    /* Copy the SPI plan into its own context */
    newplan = (SPIPlanPtr) palloc0(sizeof(_SPI_plan));
    newplan->magic = _SPI_PLAN_MAGIC;
    newplan->plancxt = plancxt;
    newplan->parse_mode = plan->parse_mode;
    newplan->cursor_options = plan->cursor_options;
    newplan->nargs = plan->nargs;
    if (plan->nargs > 0)
    {
        newplan->argtypes = (Oid *) palloc(plan->nargs * sizeof(Oid));
        memcpy(newplan->argtypes, plan->argtypes, plan->nargs * sizeof(Oid));
    }
    else
        newplan->argtypes = NULL;
    newplan->parserSetup = plan->parserSetup;
    newplan->parserSetupArg = plan->parserSetupArg;
 
    /* Copy all the plancache entries */
    foreach(lc, plan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
        CachedPlanSource *newsource;
 
        newsource = CopyCachedPlan(plansource);
        newplan->plancache_list = lappend(newplan->plancache_list, newsource);
    }
 
    MemoryContextSwitchTo(oldcxt);
 
    /*
     * Mark it saved, reparent it under CacheMemoryContext, and mark all the
     * component CachedPlanSources as saved.  This sequence cannot fail
     * partway through, so there's no risk of long-term memory leakage.
     */
    newplan->saved = true;
    MemoryContextSetParent(newplan->plancxt, CacheMemoryContext);
 
    foreach(lc, newplan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
 
        SaveCachedPlan(plansource);
    }
 
    return newplan;
}

References _SPI_PLAN_MAGIC, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, _SPI_plan::argtypes, Assert(), CacheMemoryContext, CopyCachedPlan(), CurrentMemoryContext, _SPI_plan::cursor_options, lappend(), lfirst, _SPI_plan::magic, MemoryContextSetParent(), MemoryContextSwitchTo(), _SPI_plan::nargs, palloc(), palloc0(), _SPI_plan::parse_mode, _SPI_plan::parserSetup, _SPI_plan::parserSetupArg, plan, _SPI_plan::plancache_list, _SPI_plan::plancxt, SaveCachedPlan(), and _SPI_plan::saved.

Referenced by SPI_saveplan().

AtEOSubXact_SPI()

void AtEOSubXact_SPI	(	bool	isCommit,
		SubTransactionId	mySubid
	)

Definition at line 483 of file spi.c.

{
    bool        found = false;
 
    while (_SPI_connected >= 0)
    {
        _SPI_connection *connection = &(_SPI_stack[_SPI_connected]);
 
        if (connection->connectSubid != mySubid)
            break;              /* couldn't be any underneath it either */
 
        if (connection->internal_xact)
            break;
 
        found = true;
 
        /*
         * Release procedure memory explicitly (see note in SPI_connect)
         */
        if (connection->execCxt)
        {
            MemoryContextDelete(connection->execCxt);
            connection->execCxt = NULL;
        }
        if (connection->procCxt)
        {
            MemoryContextDelete(connection->procCxt);
            connection->procCxt = NULL;
        }
 
        /*
         * Restore outer global variables and pop the stack entry.  Unlike
         * SPI_finish(), we don't risk switching to memory contexts that might
         * be already gone.
         */
        SPI_processed = connection->outer_processed;
        SPI_tuptable = connection->outer_tuptable;
        SPI_result = connection->outer_result;
 
        _SPI_connected--;
        if (_SPI_connected < 0)
            _SPI_current = NULL;
        else
            _SPI_current = &(_SPI_stack[_SPI_connected]);
    }
 
    if (found && isCommit)
        ereport(WARNING,
                (errcode(ERRCODE_WARNING),
                 errmsg("subtransaction left non-empty SPI stack"),
                 errhint("Check for missing \"SPI_finish\" calls.")));
 
    /*
     * If we are aborting a subtransaction and there is an open SPI context
     * surrounding the subxact, clean up to prevent memory leakage.
     */
    if (_SPI_current && !isCommit)
    {
        slist_mutable_iter siter;
 
        /*
         * Throw away executor state if current executor operation was started
         * within current subxact (essentially, force a _SPI_end_call(true)).
         */
        if (_SPI_current->execSubid >= mySubid)
        {
            _SPI_current->execSubid = InvalidSubTransactionId;
            MemoryContextResetAndDeleteChildren(_SPI_current->execCxt);
        }
 
        /* throw away any tuple tables created within current subxact */
        slist_foreach_modify(siter, &_SPI_current->tuptables)
        {
            SPITupleTable *tuptable;
 
            tuptable = slist_container(SPITupleTable, next, siter.cur);
            if (tuptable->subid >= mySubid)
            {
                /*
                 * If we used SPI_freetuptable() here, its internal search of
                 * the tuptables list would make this operation O(N^2).
                 * Instead, just free the tuptable manually.  This should
                 * match what SPI_freetuptable() does.
                 */
                slist_delete_current(&siter);
                if (tuptable == _SPI_current->tuptable)
                    _SPI_current->tuptable = NULL;
                if (tuptable == SPI_tuptable)
                    SPI_tuptable = NULL;
                MemoryContextDelete(tuptable->tuptabcxt);
            }
        }
    }
}

References _SPI_connected, _SPI_current, _SPI_stack, slist_mutable_iter::cur, ereport, errcode(), errhint(), errmsg(), _SPI_connection::execCxt, _SPI_connection::execSubid, InvalidSubTransactionId, MemoryContextDelete(), MemoryContextResetAndDeleteChildren, next, slist_container, slist_delete_current(), slist_foreach_modify, SPI_processed, SPI_result, SPI_tuptable, SPITupleTable::subid, SPITupleTable::tuptabcxt, _SPI_connection::tuptable, _SPI_connection::tuptables, and WARNING.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_SPI()

void AtEOXact_SPI

(

bool

isCommit

)

Definition at line 429 of file spi.c.

{
    bool        found = false;
 
    /*
     * Pop stack entries, stopping if we find one marked internal_xact (that
     * one belongs to the caller of SPI_commit or SPI_abort).
     */
    while (_SPI_connected >= 0)
    {
        _SPI_connection *connection = &(_SPI_stack[_SPI_connected]);
 
        if (connection->internal_xact)
            break;
 
        found = true;
 
        /*
         * We need not release the procedure's memory contexts explicitly, as
         * they'll go away automatically when their parent context does; see
         * notes in SPI_connect_ext.
         */
 
        /*
         * Restore outer global variables and pop the stack entry.  Unlike
         * SPI_finish(), we don't risk switching to memory contexts that might
         * be already gone.
         */
        SPI_processed = connection->outer_processed;
        SPI_tuptable = connection->outer_tuptable;
        SPI_result = connection->outer_result;
 
        _SPI_connected--;
        if (_SPI_connected < 0)
            _SPI_current = NULL;
        else
            _SPI_current = &(_SPI_stack[_SPI_connected]);
    }
 
    /* We should only find entries to pop during an ABORT. */
    if (found && isCommit)
        ereport(WARNING,
                (errcode(ERRCODE_WARNING),
                 errmsg("transaction left non-empty SPI stack"),
                 errhint("Check for missing \"SPI_finish\" calls.")));
}

References _SPI_connected, _SPI_current, _SPI_stack, ereport, errcode(), errhint(), errmsg(), SPI_processed, SPI_result, SPI_tuptable, and WARNING.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

SPI_commit()

void SPI_commit

(

void

)

Definition at line 321 of file spi.c.

{
    _SPI_commit(false);
}

References _SPI_commit().

Referenced by exec_stmt_commit(), plperl_spi_commit(), pltcl_commit(), and PLy_commit().

SPI_commit_and_chain()

void SPI_commit_and_chain

(

void

)

Definition at line 327 of file spi.c.

{
    _SPI_commit(true);
}

References _SPI_commit().

Referenced by exec_stmt_commit().

SPI_connect()

int SPI_connect

(

void

)

Definition at line 95 of file spi.c.

{
    return SPI_connect_ext(0);
}

References SPI_connect_ext().

Referenced by check_foreign_key(), check_primary_key(), connectby(), crosstab(), cursor_to_xml(), cursor_to_xmlschema(), database_to_xml_internal(), database_to_xmlschema_internal(), get_crosstab_tuplestore(), get_tuple_of_interest(), initialize_worker_spi(), load_categories_hash(), pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_event_trigger_handler(), plperl_trigger_handler(), plpgsql_validator(), plsample_trigger_handler(), pltcl_event_trigger_handler(), pltcl_trigger_handler(), query_to_xml_and_xmlschema(), query_to_xml_internal(), query_to_xmlschema(), refresh_by_match_merge(), ri_Check_Pk_Match(), RI_FKey_cascade_del(), RI_FKey_cascade_upd(), RI_FKey_check(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_restrict(), ri_set(), schema_to_xml_internal(), schema_to_xmlschema_internal(), test_predtest(), ts_stat1(), ts_stat2(), tsquery_rewrite_query(), ttdummy(), and xpath_table().

SPI_connect_ext()

int SPI_connect_ext

(

int

options

)

Definition at line 101 of file spi.c.

{
    int         newdepth;
 
    /* Enlarge stack if necessary */
    if (_SPI_stack == NULL)
    {
        if (_SPI_connected != -1 || _SPI_stack_depth != 0)
            elog(ERROR, "SPI stack corrupted");
        newdepth = 16;
        _SPI_stack = (_SPI_connection *)
            MemoryContextAlloc(TopMemoryContext,
                               newdepth * sizeof(_SPI_connection));
        _SPI_stack_depth = newdepth;
    }
    else
    {
        if (_SPI_stack_depth <= 0 || _SPI_stack_depth <= _SPI_connected)
            elog(ERROR, "SPI stack corrupted");
        if (_SPI_stack_depth == _SPI_connected + 1)
        {
            newdepth = _SPI_stack_depth * 2;
            _SPI_stack = (_SPI_connection *)
                repalloc(_SPI_stack,
                         newdepth * sizeof(_SPI_connection));
            _SPI_stack_depth = newdepth;
        }
    }
 
    /* Enter new stack level */
    _SPI_connected++;
    Assert(_SPI_connected >= 0 && _SPI_connected < _SPI_stack_depth);
 
    _SPI_current = &(_SPI_stack[_SPI_connected]);
    _SPI_current->processed = 0;
    _SPI_current->tuptable = NULL;
    _SPI_current->execSubid = InvalidSubTransactionId;
    slist_init(&_SPI_current->tuptables);
    _SPI_current->procCxt = NULL;   /* in case we fail to create 'em */
    _SPI_current->execCxt = NULL;
    _SPI_current->connectSubid = GetCurrentSubTransactionId();
    _SPI_current->queryEnv = NULL;
    _SPI_current->atomic = (options & SPI_OPT_NONATOMIC ? false : true);
    _SPI_current->internal_xact = false;
    _SPI_current->outer_processed = SPI_processed;
    _SPI_current->outer_tuptable = SPI_tuptable;
    _SPI_current->outer_result = SPI_result;
 
    /*
     * Create memory contexts for this procedure
     *
     * In atomic contexts (the normal case), we use TopTransactionContext,
     * otherwise PortalContext, so that it lives across transaction
     * boundaries.
     *
     * XXX It could be better to use PortalContext as the parent context in
     * all cases, but we may not be inside a portal (consider deferred-trigger
     * execution).  Perhaps CurTransactionContext could be an option?  For now
     * it doesn't matter because we clean up explicitly in AtEOSubXact_SPI();
     * but see also AtEOXact_SPI().
     */
    _SPI_current->procCxt = AllocSetContextCreate(_SPI_current->atomic ? TopTransactionContext : PortalContext,
                                                  "SPI Proc",
                                                  ALLOCSET_DEFAULT_SIZES);
    _SPI_current->execCxt = AllocSetContextCreate(_SPI_current->atomic ? TopTransactionContext : _SPI_current->procCxt,
                                                  "SPI Exec",
                                                  ALLOCSET_DEFAULT_SIZES);
    /* ... and switch to procedure's context */
    _SPI_current->savedcxt = MemoryContextSwitchTo(_SPI_current->procCxt);
 
    /*
     * Reset API global variables so that current caller cannot accidentally
     * depend on state of an outer caller.
     */
    SPI_processed = 0;
    SPI_tuptable = NULL;
    SPI_result = 0;
 
    return SPI_OK_CONNECT;
}

References _SPI_connected, _SPI_current, _SPI_stack, _SPI_stack_depth, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), _SPI_connection::atomic, _SPI_connection::connectSubid, elog(), ERROR, _SPI_connection::execCxt, _SPI_connection::execSubid, false, GetCurrentSubTransactionId(), _SPI_connection::internal_xact, InvalidSubTransactionId, MemoryContextAlloc(), MemoryContextSwitchTo(), _SPI_connection::outer_processed, _SPI_connection::outer_result, _SPI_connection::outer_tuptable, PortalContext, _SPI_connection::procCxt, _SPI_connection::processed, _SPI_connection::queryEnv, repalloc(), _SPI_connection::savedcxt, slist_init(), SPI_OK_CONNECT, SPI_OPT_NONATOMIC, SPI_processed, SPI_result, SPI_tuptable, TopMemoryContext, TopTransactionContext, _SPI_connection::tuptable, and _SPI_connection::tuptables.

Referenced by plperl_func_handler(), plperl_inline_handler(), plpgsql_call_handler(), plpgsql_inline_handler(), plpython3_call_handler(), plpython3_inline_handler(), pltcl_func_handler(), and SPI_connect().

SPI_copytuple()

HeapTuple SPI_copytuple

(

HeapTuple

tuple

)

Definition at line 1045 of file spi.c.

{
    MemoryContext oldcxt;
    HeapTuple   ctuple;
 
    if (tuple == NULL)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    if (_SPI_current == NULL)
    {
        SPI_result = SPI_ERROR_UNCONNECTED;
        return NULL;
    }
 
    oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
 
    ctuple = heap_copytuple(tuple);
 
    MemoryContextSwitchTo(oldcxt);
 
    return ctuple;
}

References _SPI_current, heap_copytuple(), MemoryContextSwitchTo(), _SPI_connection::savedcxt, SPI_ERROR_ARGUMENT, SPI_ERROR_UNCONNECTED, and SPI_result.

Referenced by get_tuple_of_interest(), and plpgsql_exec_trigger().

SPI_cursor_close()

void SPI_cursor_close

(

Portal

portal

)

Definition at line 1860 of file spi.c.

{
    if (!PortalIsValid(portal))
        elog(ERROR, "invalid portal in SPI cursor operation");
 
    PortalDrop(portal, false);
}

References elog(), ERROR, PortalDrop(), and PortalIsValid.

Referenced by exec_stmt_close(), exec_stmt_dynfors(), exec_stmt_forc(), exec_stmt_fors(), plperl_spi_cursor_close(), plperl_spi_fetchrow(), PLy_cursor_close(), PLy_cursor_dealloc(), query_to_xml_and_xmlschema(), query_to_xmlschema(), ts_stat_sql(), and tsquery_rewrite_query().

SPI_cursor_fetch()

void SPI_cursor_fetch	(	Portal	portal,
		bool	forward,
		long	count
	)

Definition at line 1804 of file spi.c.

{
    _SPI_cursor_operation(portal,
                          forward ? FETCH_FORWARD : FETCH_BACKWARD, count,
                          CreateDestReceiver(DestSPI));
    /* we know that the DestSPI receiver doesn't need a destroy call */
}

References _SPI_cursor_operation(), CreateDestReceiver(), DestSPI, FETCH_BACKWARD, and FETCH_FORWARD.

Referenced by cursor_to_xml(), exec_for_query(), plperl_spi_fetchrow(), PLy_cursor_fetch(), PLy_cursor_iternext(), ts_stat_sql(), and tsquery_rewrite_query().

SPI_cursor_find()

Portal SPI_cursor_find

(

const char *

name

)

Definition at line 1792 of file spi.c.

{
    return GetPortalByName(name);
}

References GetPortalByName(), and name.

Referenced by cursor_to_xml(), cursor_to_xmlschema(), exec_stmt_close(), exec_stmt_fetch(), exec_stmt_forc(), exec_stmt_open(), plperl_spi_cursor_close(), and plperl_spi_fetchrow().

SPI_cursor_move()

void SPI_cursor_move	(	Portal	portal,
		bool	forward,
		long	count
	)

Definition at line 1819 of file spi.c.

{
    _SPI_cursor_operation(portal,
                          forward ? FETCH_FORWARD : FETCH_BACKWARD, count,
                          None_Receiver);
}

References _SPI_cursor_operation(), FETCH_BACKWARD, FETCH_FORWARD, and None_Receiver.

SPI_cursor_open()

Portal SPI_cursor_open	(	const char *	name,
		SPIPlanPtr	plan,
		Datum *	Values,
		const char *	Nulls,
		bool	read_only
	)

Definition at line 1443 of file spi.c.

{
    Portal      portal;
    ParamListInfo paramLI;
 
    /* build transient ParamListInfo in caller's context */
    paramLI = _SPI_convert_params(plan->nargs, plan->argtypes,
                                  Values, Nulls);
 
    portal = SPI_cursor_open_internal(name, plan, paramLI, read_only);
 
    /* done with the transient ParamListInfo */
    if (paramLI)
        pfree(paramLI);
 
    return portal;
}

References _SPI_convert_params(), name, Nulls, pfree(), plan, and SPI_cursor_open_internal().

Referenced by plperl_spi_query(), plperl_spi_query_prepared(), PLy_cursor_plan(), PLy_cursor_query(), query_to_xml_and_xmlschema(), query_to_xmlschema(), ts_stat_sql(), and tsquery_rewrite_query().

SPI_cursor_open_internal()

static Portal SPI_cursor_open_internal ( const char *  name, SPIPlanPtr  plan, ParamListInfo  paramLI, bool  read_only  )

static

Definition at line 1575 of file spi.c.

{
    CachedPlanSource *plansource;
    CachedPlan *cplan;
    List       *stmt_list;
    char       *query_string;
    Snapshot    snapshot;
    MemoryContext oldcontext;
    Portal      portal;
    SPICallbackArg spicallbackarg;
    ErrorContextCallback spierrcontext;
 
    /*
     * Check that the plan is something the Portal code will special-case as
     * returning one tupleset.
     */
    if (!SPI_is_cursor_plan(plan))
    {
        /* try to give a good error message */
        const char *cmdtag;
 
        if (list_length(plan->plancache_list) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
                     errmsg("cannot open multi-query plan as cursor")));
        plansource = (CachedPlanSource *) linitial(plan->plancache_list);
        /* A SELECT that fails SPI_is_cursor_plan() must be SELECT INTO */
        if (plansource->commandTag == CMDTAG_SELECT)
            cmdtag = "SELECT INTO";
        else
            cmdtag = GetCommandTagName(plansource->commandTag);
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
        /* translator: %s is name of a SQL command, eg INSERT */
                 errmsg("cannot open %s query as cursor", cmdtag)));
    }
 
    Assert(list_length(plan->plancache_list) == 1);
    plansource = (CachedPlanSource *) linitial(plan->plancache_list);
 
    /* Push the SPI stack */
    if (_SPI_begin_call(true) < 0)
        elog(ERROR, "SPI_cursor_open called while not connected");
 
    /* Reset SPI result (note we deliberately don't touch lastoid) */
    SPI_processed = 0;
    SPI_tuptable = NULL;
    _SPI_current->processed = 0;
    _SPI_current->tuptable = NULL;
 
    /* Create the portal */
    if (name == NULL || name[0] == '\0')
    {
        /* Use a random nonconflicting name */
        portal = CreateNewPortal();
    }
    else
    {
        /* In this path, error if portal of same name already exists */
        portal = CreatePortal(name, false, false);
    }
 
    /* Copy the plan's query string into the portal */
    query_string = MemoryContextStrdup(portal->portalContext,
                                       plansource->query_string);
 
    /*
     * Setup error traceback support for ereport(), in case GetCachedPlan
     * throws an error.
     */
    spicallbackarg.query = plansource->query_string;
    spicallbackarg.mode = plan->parse_mode;
    spierrcontext.callback = _SPI_error_callback;
    spierrcontext.arg = &spicallbackarg;
    spierrcontext.previous = error_context_stack;
    error_context_stack = &spierrcontext;
 
    /*
     * Note: for a saved plan, we mustn't have any failure occur between
     * GetCachedPlan and PortalDefineQuery; that would result in leaking our
     * plancache refcount.
     */
 
    /* Replan if needed, and increment plan refcount for portal */
    cplan = GetCachedPlan(plansource, paramLI, NULL, _SPI_current->queryEnv);
    stmt_list = cplan->stmt_list;
 
    if (!plan->saved)
    {
        /*
         * We don't want the portal to depend on an unsaved CachedPlanSource,
         * so must copy the plan into the portal's context.  An error here
         * will result in leaking our refcount on the plan, but it doesn't
         * matter because the plan is unsaved and hence transient anyway.
         */
        oldcontext = MemoryContextSwitchTo(portal->portalContext);
        stmt_list = copyObject(stmt_list);
        MemoryContextSwitchTo(oldcontext);
        ReleaseCachedPlan(cplan, NULL);
        cplan = NULL;           /* portal shouldn't depend on cplan */
    }
 
    /*
     * Set up the portal.
     */
    PortalDefineQuery(portal,
                      NULL,     /* no statement name */
                      query_string,
                      plansource->commandTag,
                      stmt_list,
                      cplan);
 
    /*
     * Set up options for portal.  Default SCROLL type is chosen the same way
     * as PerformCursorOpen does it.
     */
    portal->cursorOptions = plan->cursor_options;
    if (!(portal->cursorOptions & (CURSOR_OPT_SCROLL | CURSOR_OPT_NO_SCROLL)))
    {
        if (list_length(stmt_list) == 1 &&
            linitial_node(PlannedStmt, stmt_list)->commandType != CMD_UTILITY &&
            linitial_node(PlannedStmt, stmt_list)->rowMarks == NIL &&
            ExecSupportsBackwardScan(linitial_node(PlannedStmt, stmt_list)->planTree))
            portal->cursorOptions |= CURSOR_OPT_SCROLL;
        else
            portal->cursorOptions |= CURSOR_OPT_NO_SCROLL;
    }
 
    /*
     * Disallow SCROLL with SELECT FOR UPDATE.  This is not redundant with the
     * check in transformDeclareCursorStmt because the cursor options might
     * not have come through there.
     */
    if (portal->cursorOptions & CURSOR_OPT_SCROLL)
    {
        if (list_length(stmt_list) == 1 &&
            linitial_node(PlannedStmt, stmt_list)->commandType != CMD_UTILITY &&
            linitial_node(PlannedStmt, stmt_list)->rowMarks != NIL)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("DECLARE SCROLL CURSOR ... FOR UPDATE/SHARE is not supported"),
                     errdetail("Scrollable cursors must be READ ONLY.")));
    }
 
    /* Make current query environment available to portal at execution time. */
    portal->queryEnv = _SPI_current->queryEnv;
 
    /*
     * If told to be read-only, we'd better check for read-only queries. This
     * can't be done earlier because we need to look at the finished, planned
     * queries.  (In particular, we don't want to do it between GetCachedPlan
     * and PortalDefineQuery, because throwing an error between those steps
     * would result in leaking our plancache refcount.)
     */
    if (read_only)
    {
        ListCell   *lc;
 
        foreach(lc, stmt_list)
        {
            PlannedStmt *pstmt = lfirst_node(PlannedStmt, lc);
 
            if (!CommandIsReadOnly(pstmt))
                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 *) pstmt))));
        }
    }
 
    /* Set up the snapshot to use. */
    if (read_only)
        snapshot = GetActiveSnapshot();
    else
    {
        CommandCounterIncrement();
        snapshot = GetTransactionSnapshot();
    }
 
    /*
     * If the plan has parameters, copy them into the portal.  Note that this
     * must be done after revalidating the plan, because in dynamic parameter
     * cases the set of parameters could have changed during re-parsing.
     */
    if (paramLI)
    {
        oldcontext = MemoryContextSwitchTo(portal->portalContext);
        paramLI = copyParamList(paramLI);
        MemoryContextSwitchTo(oldcontext);
    }
 
    /*
     * Start portal execution.
     */
    PortalStart(portal, paramLI, 0, snapshot);
 
    Assert(portal->strategy != PORTAL_MULTI_QUERY);
 
    /* Pop the error context stack */
    error_context_stack = spierrcontext.previous;
 
    /* Pop the SPI stack */
    _SPI_end_call(true);
 
    /* Return the created portal */
    return portal;
}

References _SPI_begin_call(), _SPI_current, _SPI_end_call(), _SPI_error_callback(), ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, CMD_UTILITY, CommandCounterIncrement(), CommandIsReadOnly(), CachedPlanSource::commandTag, copyObject, copyParamList(), CreateCommandName(), CreateNewPortal(), CreatePortal(), CURSOR_OPT_NO_SCROLL, CURSOR_OPT_SCROLL, PortalData::cursorOptions, elog(), ereport, errcode(), errdetail(), errmsg(), ERROR, error_context_stack, ExecSupportsBackwardScan(), GetActiveSnapshot(), GetCachedPlan(), GetCommandTagName(), GetTransactionSnapshot(), lfirst_node, linitial, linitial_node, list_length(), MemoryContextStrdup(), MemoryContextSwitchTo(), SPICallbackArg::mode, name, NIL, plan, PORTAL_MULTI_QUERY, PortalData::portalContext, PortalDefineQuery(), PortalStart(), ErrorContextCallback::previous, _SPI_connection::processed, SPICallbackArg::query, CachedPlanSource::query_string, _SPI_connection::queryEnv, PortalData::queryEnv, ReleaseCachedPlan(), SPI_is_cursor_plan(), SPI_processed, SPI_tuptable, CachedPlan::stmt_list, PortalData::strategy, and _SPI_connection::tuptable.

Referenced by SPI_cursor_open(), SPI_cursor_open_with_args(), SPI_cursor_open_with_paramlist(), and SPI_cursor_parse_open().

SPI_cursor_open_with_args()

Portal SPI_cursor_open_with_args	(	const char *	name,
		const char *	src,
		int	nargs,
		Oid *	argtypes,
		Datum *	Values,
		const char *	Nulls,
		bool	read_only,
		int	cursorOptions
	)

Definition at line 1470 of file spi.c.

{
    Portal      result;
    _SPI_plan   plan;
    ParamListInfo paramLI;
 
    if (src == NULL || nargs < 0)
        elog(ERROR, "SPI_cursor_open_with_args called with invalid arguments");
 
    if (nargs > 0 && (argtypes == NULL || Values == NULL))
        elog(ERROR, "SPI_cursor_open_with_args called with missing parameters");
 
    SPI_result = _SPI_begin_call(true);
    if (SPI_result < 0)
        elog(ERROR, "SPI_cursor_open_with_args called while not connected");
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = cursorOptions;
    plan.nargs = nargs;
    plan.argtypes = argtypes;
    plan.parserSetup = NULL;
    plan.parserSetupArg = NULL;
 
    /* build transient ParamListInfo in executor context */
    paramLI = _SPI_convert_params(nargs, argtypes,
                                  Values, Nulls);
 
    _SPI_prepare_plan(src, &plan);
 
    /* We needn't copy the plan; SPI_cursor_open_internal will do so */
 
    result = SPI_cursor_open_internal(name, &plan, paramLI, read_only);
 
    /* And clean up */
    _SPI_end_call(true);
 
    return result;
}

References _SPI_begin_call(), _SPI_convert_params(), _SPI_end_call(), _SPI_PLAN_MAGIC, _SPI_prepare_plan(), elog(), ERROR, name, Nulls, plan, RAW_PARSE_DEFAULT, SPI_cursor_open_internal(), and SPI_result.

SPI_cursor_open_with_paramlist()

Portal SPI_cursor_open_with_paramlist	(	const char *	name,
		SPIPlanPtr	plan,
		ParamListInfo	params,
		bool	read_only
	)

Definition at line 1523 of file spi.c.

{
    return SPI_cursor_open_internal(name, plan, params, read_only);
}

References name, plan, and SPI_cursor_open_internal().

Referenced by exec_run_select(), exec_stmt_forc(), and exec_stmt_open().

SPI_cursor_parse_open()

Portal SPI_cursor_parse_open	(	const char *	name,
		const char *	src,
		const SPIParseOpenOptions *	options
	)

Definition at line 1531 of file spi.c.

{
    Portal      result;
    _SPI_plan   plan;
 
    if (src == NULL || options == NULL)
        elog(ERROR, "SPI_cursor_parse_open called with invalid arguments");
 
    SPI_result = _SPI_begin_call(true);
    if (SPI_result < 0)
        elog(ERROR, "SPI_cursor_parse_open called while not connected");
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = options->cursorOptions;
    if (options->params)
    {
        plan.parserSetup = options->params->parserSetup;
        plan.parserSetupArg = options->params->parserSetupArg;
    }
 
    _SPI_prepare_plan(src, &plan);
 
    /* We needn't copy the plan; SPI_cursor_open_internal will do so */
 
    result = SPI_cursor_open_internal(name, &plan,
                                      options->params, options->read_only);
 
    /* And clean up */
    _SPI_end_call(true);
 
    return result;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_PLAN_MAGIC, _SPI_prepare_plan(), elog(), ERROR, name, plan, RAW_PARSE_DEFAULT, SPI_cursor_open_internal(), and SPI_result.

Referenced by exec_dynquery_with_params().

SPI_datumTransfer()

Datum SPI_datumTransfer	(	Datum	value,
		bool	typByVal,
		int	typLen
	)

Definition at line 1359 of file spi.c.

{
    MemoryContext oldcxt;
    Datum       result;
 
    if (_SPI_current == NULL)
        elog(ERROR, "SPI_datumTransfer called while not connected to SPI");
 
    oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
 
    result = datumTransfer(value, typByVal, typLen);
 
    MemoryContextSwitchTo(oldcxt);
 
    return result;
}

References _SPI_current, datumTransfer(), elog(), ERROR, MemoryContextSwitchTo(), _SPI_connection::savedcxt, and value.

Referenced by coerce_function_result_tuple(), and plpgsql_exec_function().

spi_dest_startup()

void spi_dest_startup	(	DestReceiver *	self,
		int	operation,
		TupleDesc	typeinfo
	)

Definition at line 2117 of file spi.c.

{
    SPITupleTable *tuptable;
    MemoryContext oldcxt;
    MemoryContext tuptabcxt;
 
    if (_SPI_current == NULL)
        elog(ERROR, "spi_dest_startup called while not connected to SPI");
 
    if (_SPI_current->tuptable != NULL)
        elog(ERROR, "improper call to spi_dest_startup");
 
    /* We create the tuple table context as a child of procCxt */
 
    oldcxt = _SPI_procmem();    /* switch to procedure memory context */
 
    tuptabcxt = AllocSetContextCreate(CurrentMemoryContext,
                                      "SPI TupTable",
                                      ALLOCSET_DEFAULT_SIZES);
    MemoryContextSwitchTo(tuptabcxt);
 
    _SPI_current->tuptable = tuptable = (SPITupleTable *)
        palloc0(sizeof(SPITupleTable));
    tuptable->tuptabcxt = tuptabcxt;
    tuptable->subid = GetCurrentSubTransactionId();
 
    /*
     * The tuptable is now valid enough to be freed by AtEOSubXact_SPI, so put
     * it onto the SPI context's tuptables list.  This will ensure it's not
     * leaked even in the unlikely event the following few lines fail.
     */
    slist_push_head(&_SPI_current->tuptables, &tuptable->next);
 
    /* set up initial allocations */
    tuptable->alloced = 128;
    tuptable->vals = (HeapTuple *) palloc(tuptable->alloced * sizeof(HeapTuple));
    tuptable->numvals = 0;
    tuptable->tupdesc = CreateTupleDescCopy(typeinfo);
 
    MemoryContextSwitchTo(oldcxt);
}

References _SPI_current, _SPI_procmem(), SPITupleTable::alloced, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CreateTupleDescCopy(), CurrentMemoryContext, elog(), ERROR, GetCurrentSubTransactionId(), MemoryContextSwitchTo(), SPITupleTable::next, SPITupleTable::numvals, palloc(), palloc0(), slist_push_head(), SPITupleTable::subid, SPITupleTable::tupdesc, SPITupleTable::tuptabcxt, _SPI_connection::tuptable, _SPI_connection::tuptables, and SPITupleTable::vals.

SPI_exec()

int SPI_exec	(	const char *	src,
		long	tcount
	)

Definition at line 628 of file spi.c.

{
    return SPI_execute(src, false, tcount);
}

References SPI_execute().

Referenced by get_tuple_of_interest(), refresh_by_match_merge(), and xpath_table().

SPI_execp()

int SPI_execp	(	SPIPlanPtr	plan,
		Datum *	Values,
		const char *	Nulls,
		long	tcount
	)

Definition at line 702 of file spi.c.

{
    return SPI_execute_plan(plan, Values, Nulls, false, tcount);
}

References Nulls, plan, and SPI_execute_plan().

Referenced by check_foreign_key(), check_primary_key(), and ttdummy().

SPI_execute()

int SPI_execute	(	const char *	src,
		bool	read_only,
		long	tcount
	)

Definition at line 594 of file spi.c.

{
    _SPI_plan   plan;
    SPIExecuteOptions options;
    int         res;
 
    if (src == NULL || tcount < 0)
        return SPI_ERROR_ARGUMENT;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = CURSOR_OPT_PARALLEL_OK;
 
    _SPI_prepare_oneshot_plan(src, &plan);
 
    memset(&options, 0, sizeof(options));
    options.read_only = read_only;
    options.tcount = tcount;
 
    res = _SPI_execute_plan(&plan, &options,
                            InvalidSnapshot, InvalidSnapshot,
                            true);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, _SPI_prepare_oneshot_plan(), CURSOR_OPT_PARALLEL_OK, InvalidSnapshot, options, plan, RAW_PARSE_DEFAULT, res, and SPI_ERROR_ARGUMENT.

Referenced by build_tuplestore_recursively(), crosstab(), get_crosstab_tuplestore(), initialize_worker_spi(), load_categories_hash(), plperl_spi_exec(), pltcl_SPI_execute(), PLy_spi_execute_query(), query_to_oid_list(), query_to_xml_internal(), refresh_by_match_merge(), and SPI_exec().

SPI_execute_extended()

int SPI_execute_extended	(	const char *	src,
		const SPIExecuteOptions *	options
	)

Definition at line 635 of file spi.c.

{
    int         res;
    _SPI_plan   plan;
 
    if (src == NULL || options == NULL)
        return SPI_ERROR_ARGUMENT;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = CURSOR_OPT_PARALLEL_OK;
    if (options->params)
    {
        plan.parserSetup = options->params->parserSetup;
        plan.parserSetupArg = options->params->parserSetupArg;
    }
 
    _SPI_prepare_oneshot_plan(src, &plan);
 
    res = _SPI_execute_plan(&plan, options,
                            InvalidSnapshot, InvalidSnapshot,
                            true);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, _SPI_prepare_oneshot_plan(), CURSOR_OPT_PARALLEL_OK, InvalidSnapshot, plan, RAW_PARSE_DEFAULT, res, and SPI_ERROR_ARGUMENT.

Referenced by exec_stmt_dynexecute(), and exec_stmt_return_query().

SPI_execute_plan()

int SPI_execute_plan	(	SPIPlanPtr	plan,
		Datum *	Values,
		const char *	Nulls,
		bool	read_only,
		long	tcount
	)

Definition at line 670 of file spi.c.

{
    SPIExecuteOptions options;
    int         res;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || tcount < 0)
        return SPI_ERROR_ARGUMENT;
 
    if (plan->nargs > 0 && Values == NULL)
        return SPI_ERROR_PARAM;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    memset(&options, 0, sizeof(options));
    options.params = _SPI_convert_params(plan->nargs, plan->argtypes,
                                         Values, Nulls);
    options.read_only = read_only;
    options.tcount = tcount;
 
    res = _SPI_execute_plan(plan, &options,
                            InvalidSnapshot, InvalidSnapshot,
                            true);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_convert_params(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, InvalidSnapshot, Nulls, options, plan, res, SPI_ERROR_ARGUMENT, and SPI_ERROR_PARAM.

Referenced by pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_spi_exec_prepared(), pltcl_SPI_execute_plan(), PLy_spi_execute_plan(), SPI_execp(), and test_predtest().

SPI_execute_plan_extended()

int SPI_execute_plan_extended	(	SPIPlanPtr	plan,
		const SPIExecuteOptions *	options
	)

Definition at line 709 of file spi.c.

{
    int         res;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || options == NULL)
        return SPI_ERROR_ARGUMENT;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    res = _SPI_execute_plan(plan, options,
                            InvalidSnapshot, InvalidSnapshot,
                            true);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, InvalidSnapshot, plan, res, and SPI_ERROR_ARGUMENT.

Referenced by exec_stmt_call(), and exec_stmt_return_query().

SPI_execute_plan_with_paramlist()

int SPI_execute_plan_with_paramlist	(	SPIPlanPtr	plan,
		ParamListInfo	params,
		bool	read_only,
		long	tcount
	)

Definition at line 731 of file spi.c.

{
    SPIExecuteOptions options;
    int         res;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || tcount < 0)
        return SPI_ERROR_ARGUMENT;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    memset(&options, 0, sizeof(options));
    options.params = params;
    options.read_only = read_only;
    options.tcount = tcount;
 
    res = _SPI_execute_plan(plan, &options,
                            InvalidSnapshot, InvalidSnapshot,
                            true);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, InvalidSnapshot, options, plan, res, and SPI_ERROR_ARGUMENT.

Referenced by exec_run_select(), and exec_stmt_execsql().

SPI_execute_snapshot()

int SPI_execute_snapshot	(	SPIPlanPtr	plan,
		Datum *	Values,
		const char *	Nulls,
		Snapshot	snapshot,
		Snapshot	crosscheck_snapshot,
		bool	read_only,
		bool	fire_triggers,
		long	tcount
	)

Definition at line 771 of file spi.c.

{
    SPIExecuteOptions options;
    int         res;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || tcount < 0)
        return SPI_ERROR_ARGUMENT;
 
    if (plan->nargs > 0 && Values == NULL)
        return SPI_ERROR_PARAM;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    memset(&options, 0, sizeof(options));
    options.params = _SPI_convert_params(plan->nargs, plan->argtypes,
                                         Values, Nulls);
    options.read_only = read_only;
    options.tcount = tcount;
 
    res = _SPI_execute_plan(plan, &options,
                            snapshot, crosscheck_snapshot,
                            fire_triggers);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_convert_params(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, Nulls, options, plan, res, SPI_ERROR_ARGUMENT, and SPI_ERROR_PARAM.

Referenced by RI_Initial_Check(), RI_PartitionRemove_Check(), and ri_PerformCheck().

SPI_execute_with_args()

int SPI_execute_with_args	(	const char *	src,
		int	nargs,
		Oid *	argtypes,
		Datum *	Values,
		const char *	Nulls,
		bool	read_only,
		long	tcount
	)

Definition at line 810 of file spi.c.

{
    int         res;
    _SPI_plan   plan;
    ParamListInfo paramLI;
    SPIExecuteOptions options;
 
    if (src == NULL || nargs < 0 || tcount < 0)
        return SPI_ERROR_ARGUMENT;
 
    if (nargs > 0 && (argtypes == NULL || Values == NULL))
        return SPI_ERROR_PARAM;
 
    res = _SPI_begin_call(true);
    if (res < 0)
        return res;
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = CURSOR_OPT_PARALLEL_OK;
    plan.nargs = nargs;
    plan.argtypes = argtypes;
    plan.parserSetup = NULL;
    plan.parserSetupArg = NULL;
 
    paramLI = _SPI_convert_params(nargs, argtypes,
                                  Values, Nulls);
 
    _SPI_prepare_oneshot_plan(src, &plan);
 
    memset(&options, 0, sizeof(options));
    options.params = paramLI;
    options.read_only = read_only;
    options.tcount = tcount;
 
    res = _SPI_execute_plan(&plan, &options,
                            InvalidSnapshot, InvalidSnapshot,
                            true);
 
    _SPI_end_call(true);
    return res;
}

References _SPI_begin_call(), _SPI_convert_params(), _SPI_end_call(), _SPI_execute_plan(), _SPI_PLAN_MAGIC, _SPI_prepare_oneshot_plan(), CURSOR_OPT_PARALLEL_OK, InvalidSnapshot, Nulls, options, plan, RAW_PARSE_DEFAULT, res, SPI_ERROR_ARGUMENT, and SPI_ERROR_PARAM.

SPI_finish()

int SPI_finish

(

void

)

Definition at line 183 of file spi.c.

{
    int         res;
 
    res = _SPI_begin_call(false);   /* just check we're connected */
    if (res < 0)
        return res;
 
    /* Restore memory context as it was before procedure call */
    MemoryContextSwitchTo(_SPI_current->savedcxt);
 
    /* Release memory used in procedure call (including tuptables) */
    MemoryContextDelete(_SPI_current->execCxt);
    _SPI_current->execCxt = NULL;
    MemoryContextDelete(_SPI_current->procCxt);
    _SPI_current->procCxt = NULL;
 
    /*
     * Restore outer API variables, especially SPI_tuptable which is probably
     * pointing at a just-deleted tuptable
     */
    SPI_processed = _SPI_current->outer_processed;
    SPI_tuptable = _SPI_current->outer_tuptable;
    SPI_result = _SPI_current->outer_result;
 
    /* Exit stack level */
    _SPI_connected--;
    if (_SPI_connected < 0)
        _SPI_current = NULL;
    else
        _SPI_current = &(_SPI_stack[_SPI_connected]);
 
    return SPI_OK_FINISH;
}

References _SPI_begin_call(), _SPI_connected, _SPI_current, _SPI_stack, _SPI_connection::execCxt, MemoryContextDelete(), MemoryContextSwitchTo(), _SPI_connection::outer_processed, _SPI_connection::outer_result, _SPI_connection::outer_tuptable, _SPI_connection::procCxt, res, _SPI_connection::savedcxt, SPI_OK_FINISH, SPI_processed, SPI_result, and SPI_tuptable.

Referenced by check_foreign_key(), check_primary_key(), connectby(), crosstab(), cursor_to_xml(), cursor_to_xmlschema(), database_to_xml_internal(), database_to_xmlschema_internal(), get_crosstab_tuplestore(), get_tuple_of_interest(), initialize_worker_spi(), load_categories_hash(), pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_event_trigger_handler(), plperl_func_handler(), plperl_inline_handler(), plperl_trigger_handler(), plpgsql_call_handler(), plpgsql_inline_handler(), plpgsql_validator(), plsample_trigger_handler(), pltcl_event_trigger_handler(), pltcl_func_handler(), pltcl_trigger_handler(), PLy_exec_function(), PLy_exec_trigger(), query_to_xml_and_xmlschema(), query_to_xml_internal(), query_to_xmlschema(), refresh_by_match_merge(), ri_Check_Pk_Match(), RI_FKey_cascade_del(), RI_FKey_cascade_upd(), RI_FKey_check(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_restrict(), ri_set(), schema_to_xml_internal(), schema_to_xmlschema_internal(), test_predtest(), ts_stat1(), ts_stat2(), tsquery_rewrite_query(), ttdummy(), and xpath_table().

SPI_fname()

char* SPI_fname	(	TupleDesc	tupdesc,
		int	fnumber
	)

Definition at line 1196 of file spi.c.

{
    const FormData_pg_attribute *att;
 
    SPI_result = 0;
 
    if (fnumber > tupdesc->natts || fnumber == 0 ||
        fnumber <= FirstLowInvalidHeapAttributeNumber)
    {
        SPI_result = SPI_ERROR_NOATTRIBUTE;
        return NULL;
    }
 
    if (fnumber > 0)
        att = TupleDescAttr(tupdesc, fnumber - 1);
    else
        att = SystemAttributeDefinition(fnumber);
 
    return pstrdup(NameStr(att->attname));
}

References FirstLowInvalidHeapAttributeNumber, FormData_pg_attribute, NameStr, TupleDescData::natts, pstrdup(), SPI_ERROR_NOATTRIBUTE, SPI_result, SystemAttributeDefinition(), and TupleDescAttr.

Referenced by get_pkey_attnames(), and SPI_sql_row_to_xmlelement().

SPI_fnumber()

int SPI_fnumber	(	TupleDesc	tupdesc,
		const char *	fname
	)

Definition at line 1173 of file spi.c.

{
    int         res;
    const FormData_pg_attribute *sysatt;
 
    for (res = 0; res < tupdesc->natts; res++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, res);
 
        if (namestrcmp(&attr->attname, fname) == 0 &&
            !attr->attisdropped)
            return res + 1;
    }
 
    sysatt = SystemAttributeByName(fname);
    if (sysatt != NULL)
        return sysatt->attnum;
 
    /* SPI_ERROR_NOATTRIBUTE is different from all sys column numbers */
    return SPI_ERROR_NOATTRIBUTE;
}

References FormData_pg_attribute, namestrcmp(), TupleDescData::natts, res, SPI_ERROR_NOATTRIBUTE, SystemAttributeByName(), and TupleDescAttr.

Referenced by autoinc(), check_foreign_key(), check_primary_key(), insert_username(), lo_manage(), make_ruledef(), make_viewdef(), moddatetime(), plperl_build_tuple_result(), plperl_modify_tuple(), pltcl_build_tuple_result(), PLy_modify_tuple(), tsvector_update_trigger(), and ttdummy().

SPI_freeplan()

int SPI_freeplan

(

SPIPlanPtr

plan

)

Definition at line 1023 of file spi.c.

{
    ListCell   *lc;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
        return SPI_ERROR_ARGUMENT;
 
    /* Release the plancache entries */
    foreach(lc, plan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
 
        DropCachedPlan(plansource);
    }
 
    /* Now get rid of the _SPI_plan and subsidiary data in its plancxt */
    MemoryContextDelete(plan->plancxt);
 
    return 0;
}

References _SPI_PLAN_MAGIC, DropCachedPlan(), lfirst, MemoryContextDelete(), plan, and SPI_ERROR_ARGUMENT.

Referenced by free_expr(), plperl_spi_freeplan(), plperl_spi_prepare(), plperl_spi_query(), PLy_cursor_query(), PLy_plan_dealloc(), ri_FetchPreparedPlan(), ts_stat_sql(), and tsquery_rewrite_query().

SPI_freetuple()

void SPI_freetuple

(

HeapTuple

tuple

)

Definition at line 1377 of file spi.c.

{
    /* No longer need to worry which context tuple was in... */
    heap_freetuple(tuple);
}

References heap_freetuple().

SPI_freetuptable()

void SPI_freetuptable

(

SPITupleTable *

tuptable

)

Definition at line 1384 of file spi.c.

{
    bool        found = false;
 
    /* ignore call if NULL pointer */
    if (tuptable == NULL)
        return;
 
    /*
     * Search only the topmost SPI context for a matching tuple table.
     */
    if (_SPI_current != NULL)
    {
        slist_mutable_iter siter;
 
        /* find tuptable in active list, then remove it */
        slist_foreach_modify(siter, &_SPI_current->tuptables)
        {
            SPITupleTable *tt;
 
            tt = slist_container(SPITupleTable, next, siter.cur);
            if (tt == tuptable)
            {
                slist_delete_current(&siter);
                found = true;
                break;
            }
        }
    }
 
    /*
     * Refuse the deletion if we didn't find it in the topmost SPI context.
     * This is primarily a guard against double deletion, but might prevent
     * other errors as well.  Since the worst consequence of not deleting a
     * tuptable would be a transient memory leak, this is just a WARNING.
     */
    if (!found)
    {
        elog(WARNING, "attempt to delete invalid SPITupleTable %p", tuptable);
        return;
    }
 
    /* for safety, reset global variables that might point at tuptable */
    if (tuptable == _SPI_current->tuptable)
        _SPI_current->tuptable = NULL;
    if (tuptable == SPI_tuptable)
        SPI_tuptable = NULL;
 
    /* release all memory belonging to tuptable */
    MemoryContextDelete(tuptable->tuptabcxt);
}

References _SPI_current, slist_mutable_iter::cur, elog(), MemoryContextDelete(), next, slist_container, slist_delete_current(), slist_foreach_modify, SPI_tuptable, SPITupleTable::tuptabcxt, _SPI_connection::tuptable, _SPI_connection::tuptables, and WARNING.

Referenced by _SPI_execute_plan(), exec_eval_cleanup(), exec_for_query(), exec_stmt_call(), exec_stmt_dynexecute(), exec_stmt_execsql(), exec_stmt_fetch(), plperl_spi_execute_fetch_result(), plperl_spi_fetchrow(), pltcl_process_SPI_result(), PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_spi_execute_fetch_result(), ts_stat_sql(), and tsquery_rewrite_query().

SPI_getargcount()

int SPI_getargcount

(

SPIPlanPtr

plan

)

Definition at line 1888 of file spi.c.

{
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return -1;
    }
    return plan->nargs;
}

References _SPI_PLAN_MAGIC, plan, SPI_ERROR_ARGUMENT, and SPI_result.

SPI_getargtypeid()

Oid SPI_getargtypeid	(	SPIPlanPtr	plan,
		int	argIndex
	)

Definition at line 1873 of file spi.c.

{
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC ||
        argIndex < 0 || argIndex >= plan->nargs)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return InvalidOid;
    }
    return plan->argtypes[argIndex];
}

References _SPI_PLAN_MAGIC, InvalidOid, plan, SPI_ERROR_ARGUMENT, and SPI_result.

SPI_getbinval()

Datum SPI_getbinval	(	HeapTuple	tuple,
		TupleDesc	tupdesc,
		int	fnumber,
		bool *	isnull
	)

Definition at line 1250 of file spi.c.

{
    SPI_result = 0;
 
    if (fnumber > tupdesc->natts || fnumber == 0 ||
        fnumber <= FirstLowInvalidHeapAttributeNumber)
    {
        SPI_result = SPI_ERROR_NOATTRIBUTE;
        *isnull = true;
        return (Datum) NULL;
    }
 
    return heap_getattr(tuple, fnumber, tupdesc, isnull);
}

References FirstLowInvalidHeapAttributeNumber, heap_getattr(), TupleDescData::natts, SPI_ERROR_NOATTRIBUTE, and SPI_result.

Referenced by autoinc(), check_foreign_key(), check_primary_key(), exec_eval_expr(), initialize_worker_spi(), make_ruledef(), make_viewdef(), query_to_oid_list(), SPI_sql_row_to_xmlelement(), test_predtest(), ts_stat_sql(), tsquery_rewrite_query(), tsvector_update_trigger(), and ttdummy().

SPI_getnspname()

char* SPI_getnspname

(

Relation

rel

)

Definition at line 1330 of file spi.c.

{
    return get_namespace_name(RelationGetNamespace(rel));
}

References get_namespace_name(), and RelationGetNamespace.

Referenced by plperl_trigger_build_args(), plsample_trigger_handler(), pltcl_trigger_handler(), and PLy_trigger_build_args().

SPI_getrelname()

char* SPI_getrelname

(

Relation

rel

)

Definition at line 1324 of file spi.c.

{
    return pstrdup(RelationGetRelationName(rel));
}

References pstrdup(), and RelationGetRelationName.

Referenced by autoinc(), check_foreign_key(), check_primary_key(), insert_username(), moddatetime(), plperl_trigger_build_args(), plsample_trigger_handler(), pltcl_trigger_handler(), PLy_trigger_build_args(), and ttdummy().

SPI_gettype()

char* SPI_gettype	(	TupleDesc	tupdesc,
		int	fnumber
	)

Definition at line 1266 of file spi.c.

{
    Oid         typoid;
    HeapTuple   typeTuple;
    char       *result;
 
    SPI_result = 0;
 
    if (fnumber > tupdesc->natts || fnumber == 0 ||
        fnumber <= FirstLowInvalidHeapAttributeNumber)
    {
        SPI_result = SPI_ERROR_NOATTRIBUTE;
        return NULL;
    }
 
    if (fnumber > 0)
        typoid = TupleDescAttr(tupdesc, fnumber - 1)->atttypid;
    else
        typoid = (SystemAttributeDefinition(fnumber))->atttypid;
 
    typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typoid));
 
    if (!HeapTupleIsValid(typeTuple))
    {
        SPI_result = SPI_ERROR_TYPUNKNOWN;
        return NULL;
    }
 
    result = pstrdup(NameStr(((Form_pg_type) GETSTRUCT(typeTuple))->typname));
    ReleaseSysCache(typeTuple);
    return result;
}

References FirstLowInvalidHeapAttributeNumber, GETSTRUCT, HeapTupleIsValid, NameStr, TupleDescData::natts, ObjectIdGetDatum(), pstrdup(), ReleaseSysCache(), SearchSysCache1(), SPI_ERROR_NOATTRIBUTE, SPI_ERROR_TYPUNKNOWN, SPI_result, SystemAttributeDefinition(), TupleDescAttr, TYPEOID, and typname.

Referenced by check_foreign_key().

SPI_gettypeid()

Oid SPI_gettypeid	(	TupleDesc	tupdesc,
		int	fnumber
	)

Definition at line 1306 of file spi.c.

{
    SPI_result = 0;
 
    if (fnumber > tupdesc->natts || fnumber == 0 ||
        fnumber <= FirstLowInvalidHeapAttributeNumber)
    {
        SPI_result = SPI_ERROR_NOATTRIBUTE;
        return InvalidOid;
    }
 
    if (fnumber > 0)
        return TupleDescAttr(tupdesc, fnumber - 1)->atttypid;
    else
        return (SystemAttributeDefinition(fnumber))->atttypid;
}

References FirstLowInvalidHeapAttributeNumber, InvalidOid, TupleDescData::natts, SPI_ERROR_NOATTRIBUTE, SPI_result, SystemAttributeDefinition(), and TupleDescAttr.

Referenced by autoinc(), check_foreign_key(), check_primary_key(), insert_username(), moddatetime(), SPI_sql_row_to_xmlelement(), ts_stat_sql(), tsquery_rewrite_query(), tsvector_update_trigger(), and ttdummy().

SPI_getvalue()

char* SPI_getvalue	(	HeapTuple	tuple,
		TupleDesc	tupdesc,
		int	fnumber
	)

Definition at line 1218 of file spi.c.

{
    Datum       val;
    bool        isnull;
    Oid         typoid,
                foutoid;
    bool        typisvarlena;
 
    SPI_result = 0;
 
    if (fnumber > tupdesc->natts || fnumber == 0 ||
        fnumber <= FirstLowInvalidHeapAttributeNumber)
    {
        SPI_result = SPI_ERROR_NOATTRIBUTE;
        return NULL;
    }
 
    val = heap_getattr(tuple, fnumber, tupdesc, &isnull);
    if (isnull)
        return NULL;
 
    if (fnumber > 0)
        typoid = TupleDescAttr(tupdesc, fnumber - 1)->atttypid;
    else
        typoid = (SystemAttributeDefinition(fnumber))->atttypid;
 
    getTypeOutputInfo(typoid, &foutoid, &typisvarlena);
 
    return OidOutputFunctionCall(foutoid, val);
}

References FirstLowInvalidHeapAttributeNumber, getTypeOutputInfo(), heap_getattr(), TupleDescData::natts, OidOutputFunctionCall(), SPI_ERROR_NOATTRIBUTE, SPI_result, SystemAttributeDefinition(), TupleDescAttr, and val.

Referenced by build_tuplestore_recursively(), check_foreign_key(), crosstab(), get_crosstab_tuplestore(), get_sql_insert(), get_sql_update(), lo_manage(), load_categories_hash(), make_ruledef(), make_viewdef(), refresh_by_match_merge(), triggered_change_notification(), and xpath_table().

SPI_inside_nonatomic_context()

bool SPI_inside_nonatomic_context

(

void

)

Definition at line 582 of file spi.c.

{
    if (_SPI_current == NULL)
        return false;           /* not in any SPI context at all */
    if (_SPI_current->atomic)
        return false;           /* it's atomic (ie function not procedure) */
    return true;
}

References _SPI_current, and _SPI_connection::atomic.

Referenced by StartTransaction().

SPI_is_cursor_plan()

bool SPI_is_cursor_plan

(

SPIPlanPtr

plan

)

Definition at line 1908 of file spi.c.

{
    CachedPlanSource *plansource;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return false;
    }
 
    if (list_length(plan->plancache_list) != 1)
    {
        SPI_result = 0;
        return false;           /* not exactly 1 pre-rewrite command */
    }
    plansource = (CachedPlanSource *) linitial(plan->plancache_list);
 
    /*
     * We used to force revalidation of the cached plan here, but that seems
     * unnecessary: invalidation could mean a change in the rowtype of the
     * tuples returned by a plan, but not whether it returns tuples at all.
     */
    SPI_result = 0;
 
    /* Does it return tuples? */
    if (plansource->resultDesc)
        return true;
 
    return false;
}

References _SPI_PLAN_MAGIC, linitial, list_length(), plan, CachedPlanSource::resultDesc, SPI_ERROR_ARGUMENT, and SPI_result.

Referenced by SPI_cursor_open_internal().

SPI_keepplan()

int SPI_keepplan

(

SPIPlanPtr

plan

)

Definition at line 974 of file spi.c.

{
    ListCell   *lc;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC ||
        plan->saved || plan->oneshot)
        return SPI_ERROR_ARGUMENT;
 
    /*
     * Mark it saved, reparent it under CacheMemoryContext, and mark all the
     * component CachedPlanSources as saved.  This sequence cannot fail
     * partway through, so there's no risk of long-term memory leakage.
     */
    plan->saved = true;
    MemoryContextSetParent(plan->plancxt, CacheMemoryContext);
 
    foreach(lc, plan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
 
        SaveCachedPlan(plansource);
    }
 
    return 0;
}

References _SPI_PLAN_MAGIC, CacheMemoryContext, lfirst, MemoryContextSetParent(), plan, SaveCachedPlan(), and SPI_ERROR_ARGUMENT.

Referenced by check_foreign_key(), check_primary_key(), exec_prepare_plan(), pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_spi_prepare(), pltcl_SPI_prepare(), PLy_spi_prepare(), ri_PlanCheck(), and ttdummy().

SPI_modifytuple()

HeapTuple SPI_modifytuple	(	Relation	rel,
		HeapTuple	tuple,
		int	natts,
		int *	attnum,
		Datum *	Values,
		const char *	Nulls
	)

Definition at line 1104 of file spi.c.

{
    MemoryContext oldcxt;
    HeapTuple   mtuple;
    int         numberOfAttributes;
    Datum      *v;
    bool       *n;
    int         i;
 
    if (rel == NULL || tuple == NULL || natts < 0 || attnum == NULL || Values == NULL)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    if (_SPI_current == NULL)
    {
        SPI_result = SPI_ERROR_UNCONNECTED;
        return NULL;
    }
 
    oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
 
    SPI_result = 0;
 
    numberOfAttributes = rel->rd_att->natts;
    v = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
    n = (bool *) palloc(numberOfAttributes * sizeof(bool));
 
    /* fetch old values and nulls */
    heap_deform_tuple(tuple, rel->rd_att, v, n);
 
    /* replace values and nulls */
    for (i = 0; i < natts; i++)
    {
        if (attnum[i] <= 0 || attnum[i] > numberOfAttributes)
            break;
        v[attnum[i] - 1] = Values[i];
        n[attnum[i] - 1] = (Nulls && Nulls[i] == 'n');
    }
 
    if (i == natts)             /* no errors in *attnum */
    {
        mtuple = heap_form_tuple(rel->rd_att, v, n);
 
        /*
         * copy the identification info of the old tuple: t_ctid, t_self, and
         * OID (if any)
         */
        mtuple->t_data->t_ctid = tuple->t_data->t_ctid;
        mtuple->t_self = tuple->t_self;
        mtuple->t_tableOid = tuple->t_tableOid;
    }
    else
    {
        mtuple = NULL;
        SPI_result = SPI_ERROR_NOATTRIBUTE;
    }
 
    pfree(v);
    pfree(n);
 
    MemoryContextSwitchTo(oldcxt);
 
    return mtuple;
}

References _SPI_current, attnum, heap_deform_tuple(), heap_form_tuple(), i, MemoryContextSwitchTo(), TupleDescData::natts, Nulls, palloc(), pfree(), RelationData::rd_att, _SPI_connection::savedcxt, SPI_ERROR_ARGUMENT, SPI_ERROR_NOATTRIBUTE, SPI_ERROR_UNCONNECTED, SPI_result, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by ttdummy().

SPI_palloc()

void* SPI_palloc

(

Size

size

)

Definition at line 1336 of file spi.c.

{
    if (_SPI_current == NULL)
        elog(ERROR, "SPI_palloc called while not connected to SPI");
 
    return MemoryContextAlloc(_SPI_current->savedcxt, size);
}

References _SPI_current, elog(), ERROR, MemoryContextAlloc(), and _SPI_connection::savedcxt.

Referenced by _SPI_strdup(), and coerce_function_result_tuple().

SPI_pfree()

void SPI_pfree

(

void *

pointer

)

Definition at line 1352 of file spi.c.

{
    /* No longer need to worry which context chunk was in... */
    pfree(pointer);
}

References pfree().

SPI_plan_get_cached_plan()

CachedPlan* SPI_plan_get_cached_plan

(

SPIPlanPtr

plan

)

Definition at line 2070 of file spi.c.

{
    CachedPlanSource *plansource;
    CachedPlan *cplan;
    SPICallbackArg spicallbackarg;
    ErrorContextCallback spierrcontext;
 
    Assert(plan->magic == _SPI_PLAN_MAGIC);
 
    /* Can't support one-shot plans here */
    if (plan->oneshot)
        return NULL;
 
    /* Must have exactly one CachedPlanSource */
    if (list_length(plan->plancache_list) != 1)
        return NULL;
    plansource = (CachedPlanSource *) linitial(plan->plancache_list);
 
    /* Setup error traceback support for ereport() */
    spicallbackarg.query = plansource->query_string;
    spicallbackarg.mode = plan->parse_mode;
    spierrcontext.callback = _SPI_error_callback;
    spierrcontext.arg = &spicallbackarg;
    spierrcontext.previous = error_context_stack;
    error_context_stack = &spierrcontext;
 
    /* Get the generic plan for the query */
    cplan = GetCachedPlan(plansource, NULL,
                          plan->saved ? CurrentResourceOwner : NULL,
                          _SPI_current->queryEnv);
    Assert(cplan == plansource->gplan);
 
    /* Pop the error context stack */
    error_context_stack = spierrcontext.previous;
 
    return cplan;
}

References _SPI_current, _SPI_error_callback(), _SPI_PLAN_MAGIC, ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, CurrentResourceOwner, error_context_stack, GetCachedPlan(), CachedPlanSource::gplan, linitial, list_length(), SPICallbackArg::mode, plan, ErrorContextCallback::previous, SPICallbackArg::query, CachedPlanSource::query_string, and _SPI_connection::queryEnv.

Referenced by exec_eval_simple_expr(), exec_simple_check_plan(), and test_predtest().

SPI_plan_get_plan_sources()

List* SPI_plan_get_plan_sources

(

SPIPlanPtr

plan

)

Definition at line 2051 of file spi.c.

{
    Assert(plan->magic == _SPI_PLAN_MAGIC);
    return plan->plancache_list;
}

References _SPI_PLAN_MAGIC, Assert(), and plan.

Referenced by exec_simple_check_plan(), exec_stmt_execsql(), and make_callstmt_target().

SPI_plan_is_valid()

bool SPI_plan_is_valid

(

SPIPlanPtr

plan

)

Definition at line 1946 of file spi.c.

{
    ListCell   *lc;
 
    Assert(plan->magic == _SPI_PLAN_MAGIC);
 
    foreach(lc, plan->plancache_list)
    {
        CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
 
        if (!CachedPlanIsValid(plansource))
            return false;
    }
    return true;
}

References _SPI_PLAN_MAGIC, Assert(), CachedPlanIsValid(), lfirst, and plan.

Referenced by ri_FetchPreparedPlan().

SPI_prepare()

SPIPlanPtr SPI_prepare	(	const char *	src,
		int	nargs,
		Oid *	argtypes
	)

Definition at line 858 of file spi.c.

{
    return SPI_prepare_cursor(src, nargs, argtypes, 0);
}

References SPI_prepare_cursor().

Referenced by check_foreign_key(), check_primary_key(), pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_spi_prepare(), plperl_spi_query(), pltcl_SPI_prepare(), PLy_cursor_query(), PLy_spi_prepare(), query_to_xml_and_xmlschema(), query_to_xmlschema(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PlanCheck(), test_predtest(), ts_stat_sql(), tsquery_rewrite_query(), and ttdummy().

SPI_prepare_cursor()

SPIPlanPtr SPI_prepare_cursor	(	const char *	src,
		int	nargs,
		Oid *	argtypes,
		int	cursorOptions
	)

Definition at line 864 of file spi.c.

{
    _SPI_plan   plan;
    SPIPlanPtr  result;
 
    if (src == NULL || nargs < 0 || (nargs > 0 && argtypes == NULL))
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    SPI_result = _SPI_begin_call(true);
    if (SPI_result < 0)
        return NULL;
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = cursorOptions;
    plan.nargs = nargs;
    plan.argtypes = argtypes;
    plan.parserSetup = NULL;
    plan.parserSetupArg = NULL;
 
    _SPI_prepare_plan(src, &plan);
 
    /* copy plan to procedure context */
    result = _SPI_make_plan_non_temp(&plan);
 
    _SPI_end_call(true);
 
    return result;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_make_plan_non_temp(), _SPI_PLAN_MAGIC, _SPI_prepare_plan(), plan, RAW_PARSE_DEFAULT, SPI_ERROR_ARGUMENT, and SPI_result.

Referenced by SPI_prepare().

SPI_prepare_extended()

SPIPlanPtr SPI_prepare_extended	(	const char *	src,
		const SPIPrepareOptions *	options
	)

Definition at line 900 of file spi.c.

{
    _SPI_plan   plan;
    SPIPlanPtr  result;
 
    if (src == NULL || options == NULL)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    SPI_result = _SPI_begin_call(true);
    if (SPI_result < 0)
        return NULL;
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = options->parseMode;
    plan.cursor_options = options->cursorOptions;
    plan.nargs = 0;
    plan.argtypes = NULL;
    plan.parserSetup = options->parserSetup;
    plan.parserSetupArg = options->parserSetupArg;
 
    _SPI_prepare_plan(src, &plan);
 
    /* copy plan to procedure context */
    result = _SPI_make_plan_non_temp(&plan);
 
    _SPI_end_call(true);
 
    return result;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_make_plan_non_temp(), _SPI_PLAN_MAGIC, _SPI_prepare_plan(), plan, SPI_ERROR_ARGUMENT, and SPI_result.

Referenced by exec_prepare_plan().

SPI_prepare_params()

SPIPlanPtr SPI_prepare_params	(	const char *	src,
		ParserSetupHook	parserSetup,
		void *	parserSetupArg,
		int	cursorOptions
	)

Definition at line 936 of file spi.c.

{
    _SPI_plan   plan;
    SPIPlanPtr  result;
 
    if (src == NULL)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    SPI_result = _SPI_begin_call(true);
    if (SPI_result < 0)
        return NULL;
 
    memset(&plan, 0, sizeof(_SPI_plan));
    plan.magic = _SPI_PLAN_MAGIC;
    plan.parse_mode = RAW_PARSE_DEFAULT;
    plan.cursor_options = cursorOptions;
    plan.nargs = 0;
    plan.argtypes = NULL;
    plan.parserSetup = parserSetup;
    plan.parserSetupArg = parserSetupArg;
 
    _SPI_prepare_plan(src, &plan);
 
    /* copy plan to procedure context */
    result = _SPI_make_plan_non_temp(&plan);
 
    _SPI_end_call(true);
 
    return result;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_make_plan_non_temp(), _SPI_PLAN_MAGIC, _SPI_prepare_plan(), plan, RAW_PARSE_DEFAULT, SPI_ERROR_ARGUMENT, and SPI_result.

spi_printtup()

bool spi_printtup	(	TupleTableSlot *	slot,
		DestReceiver *	self
	)

Definition at line 2165 of file spi.c.

{
    SPITupleTable *tuptable;
    MemoryContext oldcxt;
 
    if (_SPI_current == NULL)
        elog(ERROR, "spi_printtup called while not connected to SPI");
 
    tuptable = _SPI_current->tuptable;
    if (tuptable == NULL)
        elog(ERROR, "improper call to spi_printtup");
 
    oldcxt = MemoryContextSwitchTo(tuptable->tuptabcxt);
 
    if (tuptable->numvals >= tuptable->alloced)
    {
        /* Double the size of the pointer array */
        uint64      newalloced = tuptable->alloced * 2;
 
        tuptable->vals = (HeapTuple *) repalloc_huge(tuptable->vals,
                                                     newalloced * sizeof(HeapTuple));
        tuptable->alloced = newalloced;
    }
 
    tuptable->vals[tuptable->numvals] = ExecCopySlotHeapTuple(slot);
    (tuptable->numvals)++;
 
    MemoryContextSwitchTo(oldcxt);
 
    return true;
}

References _SPI_current, SPITupleTable::alloced, elog(), ERROR, ExecCopySlotHeapTuple(), MemoryContextSwitchTo(), SPITupleTable::numvals, repalloc_huge(), SPITupleTable::tuptabcxt, _SPI_connection::tuptable, and SPITupleTable::vals.

SPI_register_relation()

int SPI_register_relation

(

EphemeralNamedRelation

enr

)

Definition at line 3273 of file spi.c.

{
    EphemeralNamedRelation match;
    int         res;
 
    if (enr == NULL || enr->md.name == NULL)
        return SPI_ERROR_ARGUMENT;
 
    res = _SPI_begin_call(false);   /* keep current memory context */
    if (res < 0)
        return res;
 
    match = _SPI_find_ENR_by_name(enr->md.name);
    if (match)
        res = SPI_ERROR_REL_DUPLICATE;
    else
    {
        if (_SPI_current->queryEnv == NULL)
            _SPI_current->queryEnv = create_queryEnv();
 
        register_ENR(_SPI_current->queryEnv, enr);
        res = SPI_OK_REL_REGISTER;
    }
 
    _SPI_end_call(false);
 
    return res;
}

References _SPI_begin_call(), _SPI_current, _SPI_end_call(), _SPI_find_ENR_by_name(), create_queryEnv(), EphemeralNamedRelationData::md, EphemeralNamedRelationMetadataData::name, _SPI_connection::queryEnv, register_ENR(), res, SPI_ERROR_ARGUMENT, SPI_ERROR_REL_DUPLICATE, and SPI_OK_REL_REGISTER.

Referenced by SPI_register_trigger_data().

SPI_register_trigger_data()

int SPI_register_trigger_data

(

TriggerData *

tdata

)

Definition at line 3340 of file spi.c.

{
    if (tdata == NULL)
        return SPI_ERROR_ARGUMENT;
 
    if (tdata->tg_newtable)
    {
        EphemeralNamedRelation enr =
        palloc(sizeof(EphemeralNamedRelationData));
        int         rc;
 
        enr->md.name = tdata->tg_trigger->tgnewtable;
        enr->md.reliddesc = tdata->tg_relation->rd_id;
        enr->md.tupdesc = NULL;
        enr->md.enrtype = ENR_NAMED_TUPLESTORE;
        enr->md.enrtuples = tuplestore_tuple_count(tdata->tg_newtable);
        enr->reldata = tdata->tg_newtable;
        rc = SPI_register_relation(enr);
        if (rc != SPI_OK_REL_REGISTER)
            return rc;
    }
 
    if (tdata->tg_oldtable)
    {
        EphemeralNamedRelation enr =
        palloc(sizeof(EphemeralNamedRelationData));
        int         rc;
 
        enr->md.name = tdata->tg_trigger->tgoldtable;
        enr->md.reliddesc = tdata->tg_relation->rd_id;
        enr->md.tupdesc = NULL;
        enr->md.enrtype = ENR_NAMED_TUPLESTORE;
        enr->md.enrtuples = tuplestore_tuple_count(tdata->tg_oldtable);
        enr->reldata = tdata->tg_oldtable;
        rc = SPI_register_relation(enr);
        if (rc != SPI_OK_REL_REGISTER)
            return rc;
    }
 
    return SPI_OK_TD_REGISTER;
}

References ENR_NAMED_TUPLESTORE, EphemeralNamedRelationMetadataData::enrtuples, EphemeralNamedRelationMetadataData::enrtype, EphemeralNamedRelationData::md, EphemeralNamedRelationMetadataData::name, palloc(), RelationData::rd_id, EphemeralNamedRelationData::reldata, EphemeralNamedRelationMetadataData::reliddesc, SPI_ERROR_ARGUMENT, SPI_OK_REL_REGISTER, SPI_OK_TD_REGISTER, SPI_register_relation(), TriggerData::tg_newtable, TriggerData::tg_oldtable, TriggerData::tg_relation, TriggerData::tg_trigger, Trigger::tgnewtable, Trigger::tgoldtable, EphemeralNamedRelationMetadataData::tupdesc, and tuplestore_tuple_count().

Referenced by plperl_trigger_handler(), plpgsql_exec_trigger(), plsample_trigger_handler(), pltcl_trigger_handler(), and PLy_exec_trigger().

SPI_repalloc()

void* SPI_repalloc	(	void *	pointer,
		Size	size
	)

Definition at line 1345 of file spi.c.

{
    /* No longer need to worry which context chunk was in... */
    return repalloc(pointer, size);
}

References repalloc().

SPI_result_code_string()

const char* SPI_result_code_string

(

int

code

)

Definition at line 1970 of file spi.c.

{
    static char buf[64];
 
    switch (code)
    {
        case SPI_ERROR_CONNECT:
            return "SPI_ERROR_CONNECT";
        case SPI_ERROR_COPY:
            return "SPI_ERROR_COPY";
        case SPI_ERROR_OPUNKNOWN:
            return "SPI_ERROR_OPUNKNOWN";
        case SPI_ERROR_UNCONNECTED:
            return "SPI_ERROR_UNCONNECTED";
        case SPI_ERROR_ARGUMENT:
            return "SPI_ERROR_ARGUMENT";
        case SPI_ERROR_PARAM:
            return "SPI_ERROR_PARAM";
        case SPI_ERROR_TRANSACTION:
            return "SPI_ERROR_TRANSACTION";
        case SPI_ERROR_NOATTRIBUTE:
            return "SPI_ERROR_NOATTRIBUTE";
        case SPI_ERROR_NOOUTFUNC:
            return "SPI_ERROR_NOOUTFUNC";
        case SPI_ERROR_TYPUNKNOWN:
            return "SPI_ERROR_TYPUNKNOWN";
        case SPI_ERROR_REL_DUPLICATE:
            return "SPI_ERROR_REL_DUPLICATE";
        case SPI_ERROR_REL_NOT_FOUND:
            return "SPI_ERROR_REL_NOT_FOUND";
        case SPI_OK_CONNECT:
            return "SPI_OK_CONNECT";
        case SPI_OK_FINISH:
            return "SPI_OK_FINISH";
        case SPI_OK_FETCH:
            return "SPI_OK_FETCH";
        case SPI_OK_UTILITY:
            return "SPI_OK_UTILITY";
        case SPI_OK_SELECT:
            return "SPI_OK_SELECT";
        case SPI_OK_SELINTO:
            return "SPI_OK_SELINTO";
        case SPI_OK_INSERT:
            return "SPI_OK_INSERT";
        case SPI_OK_DELETE:
            return "SPI_OK_DELETE";
        case SPI_OK_UPDATE:
            return "SPI_OK_UPDATE";
        case SPI_OK_CURSOR:
            return "SPI_OK_CURSOR";
        case SPI_OK_INSERT_RETURNING:
            return "SPI_OK_INSERT_RETURNING";
        case SPI_OK_DELETE_RETURNING:
            return "SPI_OK_DELETE_RETURNING";
        case SPI_OK_UPDATE_RETURNING:
            return "SPI_OK_UPDATE_RETURNING";
        case SPI_OK_REWRITTEN:
            return "SPI_OK_REWRITTEN";
        case SPI_OK_REL_REGISTER:
            return "SPI_OK_REL_REGISTER";
        case SPI_OK_REL_UNREGISTER:
            return "SPI_OK_REL_UNREGISTER";
        case SPI_OK_TD_REGISTER:
            return "SPI_OK_TD_REGISTER";
        case SPI_OK_MERGE:
            return "SPI_OK_MERGE";
    }
    /* Unrecognized code ... return something useful ... */
    sprintf(buf, "Unrecognized SPI code %d", code);
    return buf;
}

References buf, SPI_ERROR_ARGUMENT, SPI_ERROR_CONNECT, SPI_ERROR_COPY, SPI_ERROR_NOATTRIBUTE, SPI_ERROR_NOOUTFUNC, SPI_ERROR_OPUNKNOWN, SPI_ERROR_PARAM, SPI_ERROR_REL_DUPLICATE, SPI_ERROR_REL_NOT_FOUND, SPI_ERROR_TRANSACTION, SPI_ERROR_TYPUNKNOWN, SPI_ERROR_UNCONNECTED, SPI_OK_CONNECT, SPI_OK_CURSOR, SPI_OK_DELETE, SPI_OK_DELETE_RETURNING, SPI_OK_FETCH, SPI_OK_FINISH, SPI_OK_INSERT, SPI_OK_INSERT_RETURNING, SPI_OK_MERGE, SPI_OK_REL_REGISTER, SPI_OK_REL_UNREGISTER, SPI_OK_REWRITTEN, SPI_OK_SELECT, SPI_OK_SELINTO, SPI_OK_TD_REGISTER, SPI_OK_UPDATE, SPI_OK_UPDATE_RETURNING, SPI_OK_UTILITY, and sprintf.

Referenced by check_foreign_key(), check_primary_key(), exec_dynquery_with_params(), exec_prepare_plan(), exec_run_select(), exec_stmt_call(), exec_stmt_dynexecute(), exec_stmt_execsql(), exec_stmt_forc(), exec_stmt_open(), exec_stmt_return_query(), plperl_spi_execute_fetch_result(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), plpgsql_call_handler(), plpgsql_inline_handler(), plpgsql_validator(), pltcl_process_SPI_result(), PLy_cursor_plan(), PLy_cursor_query(), PLy_spi_execute_plan(), PLy_spi_execute_query(), PLy_spi_prepare(), query_to_oid_list(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PerformCheck(), ri_PlanCheck(), and ttdummy().

SPI_returntuple()

HeapTupleHeader SPI_returntuple	(	HeapTuple	tuple,
		TupleDesc	tupdesc
	)

Definition at line 1072 of file spi.c.

{
    MemoryContext oldcxt;
    HeapTupleHeader dtup;
 
    if (tuple == NULL || tupdesc == NULL)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    if (_SPI_current == NULL)
    {
        SPI_result = SPI_ERROR_UNCONNECTED;
        return NULL;
    }
 
    /* For RECORD results, make sure a typmod has been assigned */
    if (tupdesc->tdtypeid == RECORDOID &&
        tupdesc->tdtypmod < 0)
        assign_record_type_typmod(tupdesc);
 
    oldcxt = MemoryContextSwitchTo(_SPI_current->savedcxt);
 
    dtup = DatumGetHeapTupleHeader(heap_copy_tuple_as_datum(tuple, tupdesc));
 
    MemoryContextSwitchTo(oldcxt);
 
    return dtup;
}

References _SPI_current, assign_record_type_typmod(), DatumGetHeapTupleHeader, heap_copy_tuple_as_datum(), MemoryContextSwitchTo(), _SPI_connection::savedcxt, SPI_ERROR_ARGUMENT, SPI_ERROR_UNCONNECTED, SPI_result, TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by coerce_function_result_tuple().

SPI_rollback()

void SPI_rollback

(

void

)

Definition at line 414 of file spi.c.

{
    _SPI_rollback(false);
}

References _SPI_rollback().

Referenced by exec_stmt_rollback(), plperl_spi_rollback(), pltcl_rollback(), and PLy_rollback().

SPI_rollback_and_chain()

void SPI_rollback_and_chain

(

void

)

Definition at line 420 of file spi.c.

{
    _SPI_rollback(true);
}

References _SPI_rollback().

Referenced by exec_stmt_rollback().

SPI_saveplan()

SPIPlanPtr SPI_saveplan

(

SPIPlanPtr

plan

)

Definition at line 1001 of file spi.c.

{
    SPIPlanPtr  newplan;
 
    if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
    {
        SPI_result = SPI_ERROR_ARGUMENT;
        return NULL;
    }
 
    SPI_result = _SPI_begin_call(false);    /* don't change context */
    if (SPI_result < 0)
        return NULL;
 
    newplan = _SPI_save_plan(plan);
 
    SPI_result = _SPI_end_call(false);
 
    return newplan;
}

References _SPI_begin_call(), _SPI_end_call(), _SPI_PLAN_MAGIC, _SPI_save_plan(), plan, SPI_ERROR_ARGUMENT, and SPI_result.

SPI_scroll_cursor_fetch()

void SPI_scroll_cursor_fetch	(	Portal	portal,
		FetchDirection	direction,
		long	count
	)

Definition at line 1833 of file spi.c.

{
    _SPI_cursor_operation(portal,
                          direction, count,
                          CreateDestReceiver(DestSPI));
    /* we know that the DestSPI receiver doesn't need a destroy call */
}

References _SPI_cursor_operation(), CreateDestReceiver(), and DestSPI.

Referenced by exec_stmt_fetch().

SPI_scroll_cursor_move()

void SPI_scroll_cursor_move	(	Portal	portal,
		FetchDirection	direction,
		long	count
	)

Definition at line 1848 of file spi.c.

{
    _SPI_cursor_operation(portal, direction, count, None_Receiver);
}

References _SPI_cursor_operation(), and None_Receiver.

Referenced by exec_stmt_fetch().

SPI_start_transaction()

void SPI_start_transaction

(

void

)

Definition at line 223 of file spi.c.

{
}

SPI_unregister_relation()

int SPI_unregister_relation

(

const char *

name

)

Definition at line 3307 of file spi.c.

{
    EphemeralNamedRelation match;
    int         res;
 
    if (name == NULL)
        return SPI_ERROR_ARGUMENT;
 
    res = _SPI_begin_call(false);   /* keep current memory context */
    if (res < 0)
        return res;
 
    match = _SPI_find_ENR_by_name(name);
    if (match)
    {
        unregister_ENR(_SPI_current->queryEnv, match->md.name);
        res = SPI_OK_REL_UNREGISTER;
    }
    else
        res = SPI_ERROR_REL_NOT_FOUND;
 
    _SPI_end_call(false);
 
    return res;
}

References _SPI_begin_call(), _SPI_current, _SPI_end_call(), _SPI_find_ENR_by_name(), EphemeralNamedRelationData::md, name, EphemeralNamedRelationMetadataData::name, _SPI_connection::queryEnv, res, SPI_ERROR_ARGUMENT, SPI_ERROR_REL_NOT_FOUND, SPI_OK_REL_UNREGISTER, and unregister_ENR().

Variable Documentation

_SPI_connected

int _SPI_connected = -1

static

Definition at line 52 of file spi.c.

Referenced by AtEOSubXact_SPI(), AtEOXact_SPI(), SPI_connect_ext(), and SPI_finish().

_SPI_current

_SPI_connection* _SPI_current = NULL

static

Definition at line 50 of file spi.c.

Referenced by _SPI_begin_call(), _SPI_checktuples(), _SPI_commit(), _SPI_cursor_operation(), _SPI_end_call(), _SPI_execmem(), _SPI_execute_plan(), _SPI_find_ENR_by_name(), _SPI_make_plan_non_temp(), _SPI_pquery(), _SPI_prepare_plan(), _SPI_procmem(), _SPI_rollback(), AtEOSubXact_SPI(), AtEOXact_SPI(), SPI_connect_ext(), SPI_copytuple(), SPI_cursor_open_internal(), SPI_datumTransfer(), spi_dest_startup(), SPI_finish(), SPI_freetuptable(), SPI_inside_nonatomic_context(), SPI_modifytuple(), SPI_palloc(), SPI_plan_get_cached_plan(), spi_printtup(), SPI_register_relation(), SPI_returntuple(), and SPI_unregister_relation().

_SPI_stack

_SPI_connection* _SPI_stack = NULL

static

Definition at line 49 of file spi.c.

Referenced by AtEOSubXact_SPI(), AtEOXact_SPI(), SPI_connect_ext(), and SPI_finish().

_SPI_stack_depth

int _SPI_stack_depth = 0

static

Definition at line 51 of file spi.c.

Referenced by SPI_connect_ext().

SPI_processed

uint64 SPI_processed = 0

Definition at line 45 of file spi.c.

Referenced by _SPI_cursor_operation(), _SPI_execute_plan(), AtEOSubXact_SPI(), AtEOXact_SPI(), build_tuplestore_recursively(), check_foreign_key(), check_primary_key(), crosstab(), cursor_to_xml(), exec_for_query(), exec_run_select(), exec_stmt_call(), exec_stmt_dynexecute(), exec_stmt_execsql(), exec_stmt_fetch(), get_crosstab_tuplestore(), get_tuple_of_interest(), initialize_worker_spi(), load_categories_hash(), pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_spi_execute_plan(), PLy_spi_execute_query(), query_to_oid_list(), query_to_xml_internal(), refresh_by_match_merge(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PerformCheck(), SPI_connect_ext(), SPI_cursor_open_internal(), SPI_finish(), test_predtest(), ts_stat_sql(), tsquery_rewrite_query(), and xpath_table().

SPI_result

int SPI_result = 0

Definition at line 47 of file spi.c.

Referenced by AtEOSubXact_SPI(), AtEOXact_SPI(), check_foreign_key(), check_primary_key(), exec_dynquery_with_params(), exec_prepare_plan(), exec_run_select(), exec_stmt_forc(), exec_stmt_open(), plperl_spi_prepare(), plperl_spi_query(), plperl_spi_query_prepared(), PLy_cursor_plan(), PLy_cursor_query(), PLy_spi_prepare(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PlanCheck(), SPI_connect_ext(), SPI_copytuple(), SPI_cursor_open_with_args(), SPI_cursor_parse_open(), SPI_finish(), SPI_fname(), SPI_getargcount(), SPI_getargtypeid(), SPI_getbinval(), SPI_gettype(), SPI_gettypeid(), SPI_getvalue(), SPI_is_cursor_plan(), SPI_modifytuple(), SPI_prepare_cursor(), SPI_prepare_extended(), SPI_prepare_params(), SPI_returntuple(), SPI_saveplan(), and ttdummy().

SPI_tuptable

SPITupleTable* SPI_tuptable = NULL

Definition at line 46 of file spi.c.

Referenced by _SPI_cursor_operation(), _SPI_execute_plan(), AtEOSubXact_SPI(), AtEOXact_SPI(), build_tuplestore_recursively(), crosstab(), exec_for_query(), exec_run_select(), exec_stmt_call(), exec_stmt_dynexecute(), exec_stmt_execsql(), exec_stmt_fetch(), get_crosstab_tuplestore(), get_tuple_of_interest(), initialize_worker_spi(), load_categories_hash(), pg_get_ruledef_worker(), pg_get_viewdef_worker(), plperl_spi_exec(), plperl_spi_exec_prepared(), plperl_spi_fetchrow(), pltcl_SPI_execute(), pltcl_SPI_execute_plan(), PLy_cursor_fetch(), PLy_cursor_iternext(), PLy_spi_execute_plan(), PLy_spi_execute_query(), query_to_oid_list(), refresh_by_match_merge(), RI_Initial_Check(), RI_PartitionRemove_Check(), SPI_connect_ext(), SPI_cursor_open_internal(), SPI_finish(), SPI_freetuptable(), SPI_sql_row_to_xmlelement(), test_predtest(), ts_stat_sql(), tsquery_rewrite_query(), and xpath_table().