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

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 3077 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 3117 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 227 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 2849 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 3007 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 3101 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 */
         MemoryContextReset(_SPI_current->execCxt);
     }
  
     return 0;
 }

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

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 2961 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("PL/pgSQL 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 3058 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 2399 of file spi.c.

 {
     int         my_res = 0;
     uint64      my_processed = 0;
     SPITupleTable *my_tuptable = NULL;
     int         res = 0;
     bool        allow_nonatomic;
     bool        pushed_active_snap = false;
     ResourceOwner plan_owner = options->owner;
     SPICallbackArg spicallbackarg;
     ErrorContextCallback spierrcontext;
     CachedPlan *cplan = NULL;
     ListCell   *lc1;
  
     /*
      * We allow nonatomic behavior only if options->allow_nonatomic is set
      * *and* the SPI_OPT_NONATOMIC flag was given when connecting and we are
      * not inside a subtransaction.  The latter two tests match whether
      * _SPI_commit() would allow a commit; see there for more commentary.
      */
     allow_nonatomic = options->allow_nonatomic &&
         !_SPI_current->atomic && !IsSubTransaction();
  
     /*
      * 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: do nothing for queries
      * that require no snapshot.  For those that do, ensure that a Portal
      * snapshot exists; then use that, or use the entry-time ActiveSnapshot if
      * that exists and is different.
      *
      * snapshot == InvalidSnapshot, read_only = false: do nothing for queries
      * that require no snapshot.  For those that do, ensure that a Portal
      * snapshot exists; then, in atomic execution (!allow_nonatomic) take a
      * full new snapshot for each user command, and advance its command ID
      * before each querytree within the command.  In allow_nonatomic mode we
      * just use the Portal snapshot unmodified.
      *
      * 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)
     {
         /* this intentionally tests the options field not the derived value */
         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 && !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 we're not allowing nonatomic operations, tell
                  * ProcessUtility this is an atomic execution context.
                  */
                 if (allow_nonatomic)
                     context = PROCESS_UTILITY_QUERY_NONATOMIC;
                 else
                     context = PROCESS_UTILITY_QUERY;
  
                 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(), context, 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, IsSubTransaction(), 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 3280 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 3141 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 2874 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:
             if (queryDesc->plannedstmt->hasReturning)
                 res = SPI_OK_MERGE_RETURNING;
             else
                 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_MERGE_RETURNING, 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 2329 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 2221 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 3064 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 332 of file spi.c.

 {
     MemoryContext oldcontext = CurrentMemoryContext;
     SavedTransactionCharacteristics savetc;
  
     /* see comments in _SPI_commit() */
     if (_SPI_current->atomic)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_TERMINATION),
                  errmsg("invalid transaction termination")));
  
     /* see comments in _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 3209 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 482 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;
             MemoryContextReset(_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(), MemoryContextReset(), 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 428 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_rollback).
      */
     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 320 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 326 of file spi.c.

 {
     _SPI_commit(true);
 }

References _SPI_commit().

Referenced by exec_stmt_commit().

◆ SPI_connect()

int SPI_connect ( void )

Definition at line 94 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(), worker_spi_main(), and xpath_table().

◆ SPI_connect_ext()

int SPI_connect_ext ( int options )

Definition at line 100 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 1047 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 1862 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 1806 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 1794 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 1821 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 1445 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 1577 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 1472 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 1525 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 1533 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 1361 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 2123 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 630 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 704 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 596 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(), SPI_exec(), and worker_spi_main().

◆ SPI_execute_extended()

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

Definition at line 637 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 672 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 711 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 733 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 773 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 812 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 182 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(), worker_spi_main(), and xpath_table().

◆ SPI_fname()

char* SPI_fname	(	TupleDesc	tupdesc,
		int	fnumber
	)

Definition at line 1198 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 1175 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 1025 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 1379 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 1386 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 1890 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 1875 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 1252 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(), ttdummy(), and worker_spi_main().

◆ SPI_getnspname()

char* SPI_getnspname ( Relation rel )

Definition at line 1332 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 1326 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 1268 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, and typname.

Referenced by check_foreign_key().

◆ SPI_gettypeid()

Oid SPI_gettypeid	(	TupleDesc	tupdesc,
		int	fnumber
	)

Definition at line 1308 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 1220 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 581 of file spi.c.

 {
     if (_SPI_current == NULL)
         return false;           /* not in any SPI context at all */
     /* these tests must match _SPI_commit's opinion of what's atomic: */
     if (_SPI_current->atomic)
         return false;           /* it's atomic (ie function not procedure) */
     if (IsSubTransaction())
         return false;           /* if within subtransaction, it's atomic */
     return true;
 }

References _SPI_current, _SPI_connection::atomic, and IsSubTransaction().

Referenced by StartTransaction().

◆ SPI_is_cursor_plan()

bool SPI_is_cursor_plan ( SPIPlanPtr plan )

Definition at line 1910 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 976 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 1106 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 1338 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(), _SPI_connection::savedcxt, and size.

Referenced by _SPI_strdup(), and coerce_function_result_tuple().

◆ SPI_pfree()

void SPI_pfree ( void * pointer )

Definition at line 1354 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 2076 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(), make_callstmt_target(), and test_predtest().

◆ SPI_plan_get_plan_sources()

List* SPI_plan_get_plan_sources ( SPIPlanPtr plan )

Definition at line 2057 of file spi.c.

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

References _SPI_PLAN_MAGIC, Assert, and plan.

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

◆ SPI_plan_is_valid()

bool SPI_plan_is_valid ( SPIPlanPtr plan )

Definition at line 1948 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 860 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 866 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 902 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 938 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 2171 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 3297 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 3364 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 1347 of file spi.c.

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

References repalloc(), and size.

◆ SPI_result_code_string()

const char* SPI_result_code_string ( int code )

Definition at line 1972 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";
         case SPI_OK_MERGE_RETURNING:
             return "SPI_OK_MERGE_RETURNING";
     }
     /* 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_MERGE_RETURNING, 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 1074 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 413 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 419 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 1003 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 1835 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 1850 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 222 of file spi.c.

223 {

224 }

◆ SPI_unregister_relation()

int SPI_unregister_relation ( const char * name )

Definition at line 3331 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 51 of file spi.c.

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

◆ _SPI_current

◆ _SPI_stack

_SPI_connection* _SPI_stack = NULL

static

Definition at line 48 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 50 of file spi.c.

Referenced by SPI_connect_ext().

◆ SPI_processed

uint64 SPI_processed = 0

Definition at line 44 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(), worker_spi_main(), and xpath_table().

◆ SPI_result

int SPI_result = 0

◆ SPI_tuptable

SPITupleTable* SPI_tuptable = NULL

Definition at line 45 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(), worker_spi_main(), and xpath_table().

Data Structures

Typedefs

Functions

Variables

Typedef Documentation

◆ SPICallbackArg

Function Documentation

◆ _SPI_begin_call()

◆ _SPI_checktuples()

◆ _SPI_commit()

◆ _SPI_convert_params()

◆ _SPI_cursor_operation()

◆ _SPI_end_call()

◆ _SPI_error_callback()

◆ _SPI_execmem()

◆ _SPI_execute_plan()

◆ _SPI_find_ENR_by_name()

◆ _SPI_make_plan_non_temp()

◆ _SPI_pquery()

◆ _SPI_prepare_oneshot_plan()

◆ _SPI_prepare_plan()

◆ _SPI_procmem()

◆ _SPI_rollback()

◆ _SPI_save_plan()

◆ AtEOSubXact_SPI()

◆ AtEOXact_SPI()

◆ SPI_commit()

◆ SPI_commit_and_chain()

◆ SPI_connect()

◆ SPI_connect_ext()

◆ SPI_copytuple()

◆ SPI_cursor_close()

◆ SPI_cursor_fetch()

◆ SPI_cursor_find()

◆ SPI_cursor_move()

◆ SPI_cursor_open()

◆ SPI_cursor_open_internal()

◆ SPI_cursor_open_with_args()

◆ SPI_cursor_open_with_paramlist()

◆ SPI_cursor_parse_open()

◆ SPI_datumTransfer()

◆ spi_dest_startup()

◆ SPI_exec()

◆ SPI_execp()

◆ 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_fname()

◆ SPI_fnumber()

◆ SPI_freeplan()

◆ SPI_freetuple()

◆ SPI_freetuptable()

◆ SPI_getargcount()

◆ SPI_getargtypeid()

◆ SPI_getbinval()

◆ SPI_getnspname()

◆ SPI_getrelname()

◆ SPI_gettype()

◆ SPI_gettypeid()

◆ SPI_getvalue()

◆ SPI_inside_nonatomic_context()

◆ SPI_is_cursor_plan()

◆ SPI_keepplan()

◆ SPI_modifytuple()

◆ SPI_palloc()

◆ SPI_pfree()

◆ SPI_plan_get_cached_plan()

◆ SPI_plan_get_plan_sources()

◆ SPI_plan_is_valid()

◆ SPI_prepare()

◆ SPI_prepare_cursor()

◆ SPI_prepare_extended()

◆ SPI_prepare_params()

◆ spi_printtup()

◆ SPI_register_relation()