spi.h File Reference

#include "commands/trigger.h"
#include "lib/ilist.h"
#include "parser/parser.h"
#include "utils/portal.h"

Include dependency graph for spi.h:

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

Go to the source code of this file.

Data Structures
struct	SPITupleTable
struct	SPIPrepareOptions
struct	SPIExecuteOptions
struct	SPIParseOpenOptions

Macros
#define	SPI_ERROR_CONNECT   (-1)
#define	SPI_ERROR_COPY   (-2)
#define	SPI_ERROR_OPUNKNOWN   (-3)
#define	SPI_ERROR_UNCONNECTED   (-4)
#define	SPI_ERROR_CURSOR   (-5) /* not used anymore */
#define	SPI_ERROR_ARGUMENT   (-6)
#define	SPI_ERROR_PARAM   (-7)
#define	SPI_ERROR_TRANSACTION   (-8)
#define	SPI_ERROR_NOATTRIBUTE   (-9)
#define	SPI_ERROR_NOOUTFUNC   (-10)
#define	SPI_ERROR_TYPUNKNOWN   (-11)
#define	SPI_ERROR_REL_DUPLICATE   (-12)
#define	SPI_ERROR_REL_NOT_FOUND   (-13)
#define	SPI_OK_CONNECT   1
#define	SPI_OK_FINISH   2
#define	SPI_OK_FETCH   3
#define	SPI_OK_UTILITY   4
#define	SPI_OK_SELECT   5
#define	SPI_OK_SELINTO   6
#define	SPI_OK_INSERT   7
#define	SPI_OK_DELETE   8
#define	SPI_OK_UPDATE   9
#define	SPI_OK_CURSOR   10
#define	SPI_OK_INSERT_RETURNING   11
#define	SPI_OK_DELETE_RETURNING   12
#define	SPI_OK_UPDATE_RETURNING   13
#define	SPI_OK_REWRITTEN   14
#define	SPI_OK_REL_REGISTER   15
#define	SPI_OK_REL_UNREGISTER   16
#define	SPI_OK_TD_REGISTER   17
#define	SPI_OK_MERGE   18
#define	SPI_OK_MERGE_RETURNING   19
#define	SPI_OPT_NONATOMIC   (1 << 0)

Typedefs
typedef struct SPITupleTable	SPITupleTable
typedef struct SPIPrepareOptions	SPIPrepareOptions
typedef struct SPIExecuteOptions	SPIExecuteOptions
typedef struct SPIParseOpenOptions	SPIParseOpenOptions
typedef struct _SPI_plan *	SPIPlanPtr

Functions
int	SPI_connect (void)
int	SPI_connect_ext (int options)
int	SPI_finish (void)
int	SPI_execute (const char *src, bool read_only, 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_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_exec (const char *src, long tcount)
int	SPI_execp (SPIPlanPtr plan, Datum *Values, const char *Nulls, 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)
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)
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, FetchDirection direction, long count)
void	SPI_scroll_cursor_move (Portal, FetchDirection direction, long count)
void	SPI_cursor_close (Portal portal)
int	SPI_register_relation (EphemeralNamedRelation enr)
int	SPI_unregister_relation (const char *name)
int	SPI_register_trigger_data (TriggerData *tdata)
void	SPI_start_transaction (void)
void	SPI_commit (void)
void	SPI_commit_and_chain (void)
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)

Variables
PGDLLIMPORT uint64	SPI_processed
PGDLLIMPORT SPITupleTable *	SPI_tuptable
PGDLLIMPORT int	SPI_result

Macro Definition Documentation

SPI_ERROR_ARGUMENT

#define SPI_ERROR_ARGUMENT   (-6)

Definition at line 73 of file spi.h.

SPI_ERROR_CONNECT

#define SPI_ERROR_CONNECT   (-1)

Definition at line 68 of file spi.h.

SPI_ERROR_COPY

#define SPI_ERROR_COPY   (-2)

Definition at line 69 of file spi.h.

SPI_ERROR_CURSOR

#define SPI_ERROR_CURSOR   (-5) /* not used anymore */

Definition at line 72 of file spi.h.

SPI_ERROR_NOATTRIBUTE

#define SPI_ERROR_NOATTRIBUTE   (-9)

Definition at line 76 of file spi.h.

SPI_ERROR_NOOUTFUNC

#define SPI_ERROR_NOOUTFUNC   (-10)

Definition at line 77 of file spi.h.

SPI_ERROR_OPUNKNOWN

#define SPI_ERROR_OPUNKNOWN   (-3)

Definition at line 70 of file spi.h.

SPI_ERROR_PARAM

#define SPI_ERROR_PARAM   (-7)

Definition at line 74 of file spi.h.

SPI_ERROR_REL_DUPLICATE

#define SPI_ERROR_REL_DUPLICATE   (-12)

Definition at line 79 of file spi.h.

SPI_ERROR_REL_NOT_FOUND

#define SPI_ERROR_REL_NOT_FOUND   (-13)

Definition at line 80 of file spi.h.

SPI_ERROR_TRANSACTION

#define SPI_ERROR_TRANSACTION   (-8)

Definition at line 75 of file spi.h.

SPI_ERROR_TYPUNKNOWN

#define SPI_ERROR_TYPUNKNOWN   (-11)

Definition at line 78 of file spi.h.

SPI_ERROR_UNCONNECTED

#define SPI_ERROR_UNCONNECTED   (-4)

Definition at line 71 of file spi.h.

SPI_OK_CONNECT

#define SPI_OK_CONNECT   1

Definition at line 82 of file spi.h.

SPI_OK_CURSOR

#define SPI_OK_CURSOR   10

Definition at line 91 of file spi.h.

SPI_OK_DELETE

#define SPI_OK_DELETE   8

Definition at line 89 of file spi.h.

SPI_OK_DELETE_RETURNING

#define SPI_OK_DELETE_RETURNING   12

Definition at line 93 of file spi.h.

SPI_OK_FETCH

#define SPI_OK_FETCH   3

Definition at line 84 of file spi.h.

SPI_OK_FINISH

#define SPI_OK_FINISH   2

Definition at line 83 of file spi.h.

SPI_OK_INSERT

#define SPI_OK_INSERT   7

Definition at line 88 of file spi.h.

SPI_OK_INSERT_RETURNING

#define SPI_OK_INSERT_RETURNING   11

Definition at line 92 of file spi.h.

SPI_OK_MERGE

#define SPI_OK_MERGE   18

Definition at line 99 of file spi.h.

SPI_OK_MERGE_RETURNING

#define SPI_OK_MERGE_RETURNING   19

Definition at line 100 of file spi.h.

SPI_OK_REL_REGISTER

#define SPI_OK_REL_REGISTER   15

Definition at line 96 of file spi.h.

SPI_OK_REL_UNREGISTER

#define SPI_OK_REL_UNREGISTER   16

Definition at line 97 of file spi.h.

SPI_OK_REWRITTEN

#define SPI_OK_REWRITTEN   14

Definition at line 95 of file spi.h.

SPI_OK_SELECT

#define SPI_OK_SELECT   5

Definition at line 86 of file spi.h.

SPI_OK_SELINTO

#define SPI_OK_SELINTO   6

Definition at line 87 of file spi.h.

SPI_OK_TD_REGISTER

#define SPI_OK_TD_REGISTER   17

Definition at line 98 of file spi.h.

SPI_OK_UPDATE

#define SPI_OK_UPDATE   9

Definition at line 90 of file spi.h.

SPI_OK_UPDATE_RETURNING

#define SPI_OK_UPDATE_RETURNING   13

Definition at line 94 of file spi.h.

SPI_OK_UTILITY

#define SPI_OK_UTILITY   4

Definition at line 85 of file spi.h.

SPI_OPT_NONATOMIC

#define SPI_OPT_NONATOMIC   (1 << 0)

Definition at line 102 of file spi.h.

Typedef Documentation

SPIExecuteOptions

typedef struct SPIExecuteOptions SPIExecuteOptions

SPIParseOpenOptions

typedef struct SPIParseOpenOptions SPIParseOpenOptions

SPIPlanPtr

typedef struct _SPI_plan* SPIPlanPtr

Definition at line 66 of file spi.h.

SPIPrepareOptions

typedef struct SPIPrepareOptions SPIPrepareOptions

SPITupleTable

typedef struct SPITupleTable SPITupleTable

Function Documentation

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(), 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_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_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(), and check_primary_key().

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, 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, 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, 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, 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, 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, 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, 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, _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(), 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, 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(), and tsvector_update_trigger().

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(), 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(), and PLy_trigger_build_args().

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(), and tsvector_update_trigger().

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(), and ri_PlanCheck().

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.

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(), and _SPI_connection::savedcxt.

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(), and tsquery_rewrite_query().

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_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(), 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().

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(), and ri_PlanCheck().

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.

{
}

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, SPI_ERROR_ARGUMENT, SPI_ERROR_REL_NOT_FOUND, SPI_OK_REL_UNREGISTER, and unregister_ENR().

Variable Documentation

SPI_processed

PGDLLIMPORT uint64 SPI_processed

extern

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

PGDLLIMPORT int SPI_result

extern

Definition at line 46 of file spi.c.

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

SPI_tuptable

PGDLLIMPORT SPITupleTable* SPI_tuptable

extern

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